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

disdrodb/l0/routines.py

@@ -16,702 +16,1006 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
-"""Implement DISDRODB wrappers to launch L0 processing in the terminal."""
+"""Implement DISDRODB L0 processing."""
 
 import datetime
 import logging
+import os
 import time
+from typing import Optional
 
-import click
+import dask
 
+from disdrodb.api.checks import check_sensor_name
+
+# Directory
+from disdrodb.api.create_directories import (
+    create_l0_directory_structure,
+    create_logs_directory,
+    create_product_directory,
+)
+from disdrodb.api.io import find_files, remove_product
+from disdrodb.api.path import (
+    define_file_folder_path,
+    define_l0a_filename,
+    define_l0b_filename,
+    define_l0c_filename,
+    define_metadata_filepath,
+)
+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.issue import read_station_issue
+from disdrodb.l0.l0_reader import get_reader
+from disdrodb.l0.l0a_processing import (
+    read_l0a_dataframe,
+    sanitize_df,
+    write_l0a,
+)
+from disdrodb.l0.l0b_nc_processing import sanitize_ds
+from disdrodb.l0.l0b_processing import (
+    create_l0b_from_l0a,
+    set_l0b_encodings,
+    write_l0b,
+)
+from disdrodb.l0.l0c_processing import (
+    create_daily_file,
+    get_files_per_days,
+    retrieve_possible_measurement_intervals,
+)
+from disdrodb.metadata import read_station_metadata
+from disdrodb.utils.decorators import delayed_if_parallel, single_threaded_if_parallel
+
+# Logger
 from disdrodb.utils.logger import (
-    # log_warning,
-    # log_error,
+    close_logger,
+    create_logger_file,
+    create_product_logs,
+    log_error,
     log_info,
 )
-from disdrodb.utils.scripts import _execute_cmd
+
+# log_warning,
+from disdrodb.utils.writer import write_product
+from disdrodb.utils.yaml import read_yaml
 
 logger = logging.getLogger(__name__)
 
-####--------------------------------------------------------------------------.
-#### CLIck
+# -----------------------------------------------------------------------------.
+#### Creation of L0A and L0B Single Station File
 
 
-def click_l0_stations_options(function: object):
-    """Click command line options for DISDRODB archive L0 processing.
+@delayed_if_parallel
+@single_threaded_if_parallel
+def _generate_l0a(
+    filepath,
+    data_dir,
+    logs_dir,
+    campaign_name,
+    station_name,
+    # Processing info
+    reader,
+    metadata,
+    issue_dict,
+    # Processing options
+    force,
+    verbose,
+    parallel,
+):
+    """Generate L0A file from raw file."""
+    # Define product
+    product = "L0A"
+
+    # Define folder partitioning
+    folder_partitioning = get_folder_partitioning()
+
+    # Retrieve sensor name
+    sensor_name = metadata["sensor_name"]
+
+    ##------------------------------------------------------------------------.
+    # Create file logger
+    filename = os.path.basename(filepath)
+    logger, logger_filepath = create_logger_file(
+        logs_dir=logs_dir,
+        filename=filename,
+        parallel=parallel,
+    )
 
-    Parameters
-    ----------
-    function : object
-        Function.
-    """
-    function = click.option(
-        "--data_sources",
-        type=str,
-        show_default=True,
-        default="",
-        help="DISDRODB data sources to process",
-    )(function)
-    function = click.option(
-        "--campaign_names",
-        type=str,
-        show_default=True,
-        default="",
-        help="DISDRODB campaign names to process",
-    )(function)
-    function = click.option(
-        "--station_names",
-        type=str,
-        show_default=True,
-        default="",
-        help="DISDRODB station names to process",
-    )(function)
-    return function
-
-
-def click_l0_processing_options(function: object):
-    """Click command line default parameters for L0 processing options.
+    ##------------------------------------------------------------------------.
+    # Log start processing
+    msg = f"{product} processing of {filename} has started."
+    log_info(logger=logger, msg=msg, verbose=verbose)
 
-    Parameters
-    ----------
-    function : object
-        Function.
-    """
-    function = click.option(
-        "-p",
-        "--parallel",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="Process files in parallel",
-    )(function)
-    function = click.option(
-        "-d",
-        "--debugging_mode",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="Switch to debugging mode",
-    )(function)
-    function = click.option("-v", "--verbose", type=bool, show_default=True, default=True, help="Verbose")(function)
-    function = click.option(
-        "-f",
-        "--force",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="Force overwriting",
-    )(function)
-    return function
-
-
-def click_remove_l0a_option(function: object):
-    function = click.option(
-        "--remove_l0a",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="If true, remove the L0A files once the L0B processing is terminated.",
-    )(function)
-    return function
-
-
-def click_l0_archive_options(function: object):
-    """Click command line arguments for L0 processing archiving of a station.
+    ##------------------------------------------------------------------------.
+    ### - Read raw file into a dataframe and sanitize for L0A format
+    try:
+        df = reader(filepath, logger=logger)
+        df = sanitize_df(
+            df=df,
+            sensor_name=sensor_name,
+            verbose=verbose,
+            issue_dict=issue_dict,
+            logger=logger,
+        )
 
-    Parameters
-    ----------
-    function : object
-        Function.
-    """
-    function = click.option(
-        "--l0b_concat",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="Produce single L0B netCDF file.",
-    )(function)
-    function = click.option(
-        "--remove_l0b",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="If true, remove all source L0B files once L0B concatenation is terminated.",
-    )(function)
-    function = click.option(
-        "--remove_l0a",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="If true, remove the L0A files once the L0B processing is terminated.",
-    )(function)
-    function = click.option(
-        "-l0b",
-        "--l0b_processing",
-        type=bool,
-        show_default=True,
-        default=True,
-        help="Perform L0B processing.",
-    )(function)
-    function = click.option(
-        "-l0a",
-        "--l0a_processing",
-        type=bool,
-        show_default=True,
-        default=True,
-        help="Perform L0A processing.",
-    )(function)
-    return function
-
-
-def click_l0b_concat_options(function: object):
-    """Click command line default parameters for L0B concatenation.
+        ##--------------------------------------------------------------------.
+        #### - Write to Parquet
+        filename = define_l0a_filename(df=df, campaign_name=campaign_name, station_name=station_name)
+        folder_path = define_file_folder_path(df, data_dir=data_dir, folder_partitioning=folder_partitioning)
+        filepath = os.path.join(folder_path, filename)
+        write_l0a(df=df, filepath=filepath, force=force, logger=logger, verbose=verbose)
 
-    Parameters
-    ----------
-    function : object
-        Function.
-    """
-    function = click.option(
-        "--remove_l0b",
-        type=bool,
-        show_default=True,
-        default=False,
-        help="If true, remove all source L0B files once L0B concatenation is terminated.",
-    )(function)
-    function = click.option("-v", "--verbose", type=bool, show_default=True, default=False, help="Verbose")(function)
-    return function
+        ##--------------------------------------------------------------------.
+        # Clean environment
+        del df
 
+        # Log end processing
+        msg = f"{product} processing of {filename} has ended."
+        log_info(logger=logger, msg=msg, verbose=verbose)
 
-####--------------------------------------------------------------------------.
-#### Run L0A and L0B Station processing
+    # Otherwise log the error
+    except Exception as e:
+        error_type = str(type(e).__name__)
+        msg = f"{error_type}: {e}"
+        log_error(logger=logger, msg=msg, verbose=verbose)
 
+    # Close the file logger
+    close_logger(logger)
 
-def run_disdrodb_l0a_station(
-    # Station arguments
-    data_source,
+    # Return the logger file path
+    return logger_filepath
+
+
+@delayed_if_parallel
+@single_threaded_if_parallel
+def _generate_l0b(
+    filepath,
+    data_dir,
+    logs_dir,
     campaign_name,
     station_name,
+    # Processing info
+    metadata,
     # Processing options
-    force: bool = False,
-    verbose: bool = False,
-    debugging_mode: bool = False,
-    parallel: bool = True,
-    base_dir: str = None,
+    force,
+    verbose,
+    parallel,
+    debugging_mode,
 ):
-    """Run the L0A processing of a station calling the disdrodb_l0a_station in the terminal."""
-    # Define command
-    cmd = " ".join([
-        "disdrodb_run_l0a_station",
-        # Station arguments
-        data_source,
-        campaign_name,
-        station_name,
-        # Processing options
-        "--force",
-        str(force),
-        "--verbose",
-        str(verbose),
-        "--debugging_mode",
-        str(debugging_mode),
-        "--parallel",
-        str(parallel),
-        "--base_dir",
-        str(base_dir),
-    ])
-    # Execute command
-    _execute_cmd(cmd)
-    return None
-
-
-def run_disdrodb_l0b_station(
-    # Station arguments
-    data_source,
+    # Define product
+    product = "L0B"
+
+    # Define folder partitioning
+    folder_partitioning = get_folder_partitioning()
+
+    # -----------------------------------------------------------------.
+    # Create file logger
+    filename = os.path.basename(filepath)
+    logger, logger_filepath = create_logger_file(
+        logs_dir=logs_dir,
+        filename=filename,
+        parallel=parallel,
+    )
+
+    ##------------------------------------------------------------------------.
+    # Log start processing
+    msg = f"{product} processing of {filename} has started."
+    log_info(logger=logger, msg=msg, verbose=verbose)
+
+    ##------------------------------------------------------------------------.
+    # Retrieve sensor name
+    sensor_name = metadata["sensor_name"]
+    check_sensor_name(sensor_name)
+
+    ##------------------------------------------------------------------------.
+    try:
+        # Read L0A Apache Parquet file
+        df = read_l0a_dataframe(filepath, logger=logger, verbose=verbose, debugging_mode=debugging_mode)
+
+        # -----------------------------------------------------------------.
+        # Create xarray Dataset
+        ds = create_l0b_from_l0a(df=df, metadata=metadata, logger=logger, verbose=verbose)
+
+        # -----------------------------------------------------------------.
+        # Write L0B netCDF4 dataset
+        filename = define_l0b_filename(ds=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_l0b(ds, filepath=filepath, force=force)
+
+        ##--------------------------------------------------------------------.
+        # Clean environment
+        del ds, df
+
+        # Log end processing
+        msg = f"{product} processing of {filename} has ended."
+        log_info(logger=logger, msg=msg, verbose=verbose)
+
+    # Otherwise log the error
+    except Exception as e:
+        error_type = str(type(e).__name__)
+        msg = f"{error_type}: {e}"
+        log_error(logger, msg, verbose=verbose)
+
+    # Close the file logger
+    close_logger(logger)
+
+    # Return the logger file path
+    return logger_filepath
+
+
+def _generate_l0b_from_nc(
+    filepath,
+    data_dir,
+    logs_dir,
     campaign_name,
     station_name,
+    # Processing info
+    reader,
+    metadata,
+    issue_dict,
     # Processing options
-    force: bool = False,
-    verbose: bool = False,
-    debugging_mode: bool = False,
-    parallel: bool = True,
-    base_dir: str = None,
-    remove_l0a: bool = False,
+    force,
+    verbose,
+    parallel,
 ):
-    """Run the L0B processing of a station calling disdrodb_run_l0b_station in the terminal."""
-    # Define command
-    cmd = " ".join([
-        "disdrodb_run_l0b_station",
-        # Station arguments
-        data_source,
-        campaign_name,
-        station_name,
-        # Processing options
-        "--force",
-        str(force),
-        "--verbose",
-        str(verbose),
-        "--debugging_mode",
-        str(debugging_mode),
-        "--parallel",
-        str(parallel),
-        "--remove_l0a",
-        str(remove_l0a),
-        "--base_dir",
-        str(base_dir),
-    ])
-    # Execute command
-    _execute_cmd(cmd)
-    return None
-
-
-def run_disdrodb_l0b_concat_station(
-    data_source,
+
+    # -----------------------------------------------------------------.
+    # Define product name
+    product = "L0B"
+
+    # Define folder partitioning
+    folder_partitioning = get_folder_partitioning()
+
+    # Retrieve sensor name
+    sensor_name = metadata["sensor_name"]
+
+    # -----------------------------------------------------------------.
+    # Create file logger
+    filename = os.path.basename(filepath)
+    logger, logger_filepath = create_logger_file(
+        logs_dir=logs_dir,
+        filename=filename,
+        parallel=parallel,
+    )
+
+    ##------------------------------------------------------------------------.
+    # Log start processing
+    msg = f"{product} processing of {filename} has started."
+    log_info(logger=logger, msg=msg, verbose=verbose)
+
+    ##------------------------------------------------------------------------.
+    ### - Read raw netCDF and sanitize for L0B format
+    try:
+        ds = reader(filepath, logger=logger)
+        ds = sanitize_ds(
+            ds=ds,
+            sensor_name=sensor_name,
+            metadata=metadata,
+            issue_dict=issue_dict,
+            verbose=verbose,
+            logger=logger,
+        )
+
+        # -----------------------------------------------------------------.
+        # Write L0B netCDF4 dataset
+        filename = define_l0b_filename(ds=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_l0b(ds, filepath=filepath, force=force)
+
+        ##--------------------------------------------------------------------.
+        # Clean environment
+        del ds
+
+        # Log end processing
+        msg = f"L0B processing of {filename} has ended."
+        log_info(logger=logger, msg=msg, verbose=verbose)
+
+    # Otherwise log the error
+    except Exception as e:
+        error_type = str(type(e).__name__)
+        msg = f"{error_type}: {e}"
+        log_error(logger, msg, verbose=verbose)
+
+    # Close the file logger
+    close_logger(logger)
+
+    # Return the logger file path
+    return logger_filepath
+
+
+@delayed_if_parallel
+@single_threaded_if_parallel
+def _generate_l0c(
+    day,
+    filepaths,
+    data_dir,
+    logs_dir,
+    metadata_filepath,
     campaign_name,
     station_name,
-    remove_l0b=False,
-    verbose=False,
-    base_dir=None,
+    # Processing options
+    force,
+    verbose,
+    parallel,  # this is used only to initialize the correct logger !
 ):
-    """Concatenate the L0B files of a single DISDRODB station.
+    # -----------------------------------------------------------------.
+    # Define product name
+    product = "L0C"
+
+    # Define folder partitioning
+    folder_partitioning = get_folder_partitioning()
+
+    # -----------------------------------------------------------------.
+    # Create file logger
+    logger, logger_filepath = create_logger_file(
+        logs_dir=logs_dir,
+        filename=day,
+        parallel=parallel,
+    )
 
-    This function runs the ``disdrodb_run_l0b_concat_station`` script in the terminal.
-    """
-    cmd = " ".join([
-        "disdrodb_run_l0b_concat_station",
-        data_source,
-        campaign_name,
-        station_name,
-        "--remove_l0b",
-        str(remove_l0b),
-        "--verbose",
-        str(verbose),
-        "--base_dir",
-        str(base_dir),
-    ])
-    _execute_cmd(cmd)
+    ##------------------------------------------------------------------------.
+    # Log start processing
+    msg = f"{product} processing for {day} has started."
+    log_info(logger=logger, msg=msg, verbose=verbose)
+
+    ##------------------------------------------------------------------------.
+    ### Core computation
+    try:
+        # Retrieve measurement_intervals
+        # - TODO: in future available from dataset
+        metadata = read_yaml(metadata_filepath)
+        measurement_intervals = retrieve_possible_measurement_intervals(metadata)
+
+        # Produce L0C datasets
+        dict_ds = create_daily_file(
+            day=day,
+            filepaths=filepaths,
+            measurement_intervals=measurement_intervals,
+            ensure_variables_equality=True,
+            logger=logger,
+            verbose=verbose,
+        )
+
+        # Write a dataset for each sample interval
+        for ds in dict_ds.values():  # (sample_interval, ds)
+            # Write L0C netCDF4 dataset
+            if ds["time"].size > 1:
+                # Get sensor name from dataset
+                sensor_name = ds.attrs.get("sensor_name")
+                campaign_name = ds.attrs.get("campaign_name")
+                station_name = ds.attrs.get("station_name")
+
+                # Set encodings
+                ds = set_l0b_encodings(ds=ds, sensor_name=sensor_name)
+
+                # Define 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)
+
+        # Clean environment
+        del ds
+
+        # Log end processing
+        msg = f"{product} processing for {day} has ended."
+        log_info(logger=logger, msg=msg, verbose=verbose)
+
+    ##--------------------------------------------------------------------.
+    # Otherwise log the error
+    except Exception as e:
+        error_type = str(type(e).__name__)
+        msg = f"{error_type}: {e}"
+        log_error(logger, msg, verbose=verbose)
+
+    # Close the file logger
+    close_logger(logger)
+
+    # Return the logger file path
+    return logger_filepath
 
 
 ####--------------------------------------------------------------------------.
-#### Run L0 Station processing (L0A + L0B)
+#### DISDRODB Station Functions
 
 
-def run_disdrodb_l0_station(
+def run_l0a_station(
+    # Station arguments
     data_source,
     campaign_name,
     station_name,
-    # L0 archive options
-    l0a_processing: bool = True,
-    l0b_processing: bool = True,
-    l0b_concat: bool = True,
-    remove_l0a: bool = False,
-    remove_l0b: bool = False,
     # Processing options
     force: bool = False,
     verbose: bool = False,
     debugging_mode: bool = False,
     parallel: bool = True,
-    base_dir: str = None,
+    # DISDRODB root directories
+    data_archive_dir: Optional[str] = None,
+    metadata_archive_dir: Optional[str] = None,
 ):
-    """Run the L0 processing of a specific DISDRODB station from the terminal.
+    """
+    Run the L0A processing of a specific DISDRODB station when invoked from the terminal.
+
+    This function is intended to be called through the ``disdrodb_run_l0a_station``
+    command-line interface.
 
     Parameters
     ----------
     data_source : str
-        Institution name (when campaign data spans more than 1 country),
-        or country (when all campaigns (or sensor networks) are inside a given country).
-        Must be UPPER CASE.
+        The name of the institution (for campaigns spanning multiple countries) or
+        the name of the country (for campaigns or sensor networks within a single country).
+        Must be provided in UPPER CASE.
     campaign_name : str
-        Campaign name. Must be UPPER CASE.
+        The name of the campaign. Must be provided in UPPER CASE.
     station_name : str
-        Station name
-    l0a_processing : bool
-        Whether to launch processing to generate L0A Apache Parquet file(s) from raw data.
-        The default is True.
-    l0b_processing : bool
-        Whether to launch processing to generate L0B netCDF4 file(s) from L0A data.
-        The default is True.
-    l0b_concat : bool
-        Whether to concatenate all raw files into a single L0B netCDF file.
-        If l0b_concat=True, all raw files will be saved into a single L0B netCDF file.
-        If l0b_concat=False, each raw file will be converted into the corresponding L0B netCDF file.
-        The default is False.
-    remove_l0a : bool
-        Whether to keep the L0A files after having generated the L0B netCDF products.
-        The default is False.
-    remove_l0b : bool
-        Whether to remove the L0B files after having concatenated all L0B netCDF files.
-        It takes places only if l0b_concat=True
-        The default is False.
-    force : bool
-        If True, overwrite existing data into destination directories.
-        If False, raise an error if there are already data into destination directories.
-        The default is False.
-    verbose : bool
-        Whether to print detailed processing information into terminal.
-        The default is True.
-    parallel : bool
-        If True, the files are processed simultaneously in multiple processes.
-        Each process will use a single thread to avoid issues with the HDF/netCDF library.
-        By default, the number of process is defined with os.cpu_count().
-        If False, the files are processed sequentially in a single process.
-        If False, multi-threading is automatically exploited to speed up I/0 tasks.
-    debugging_mode : bool
-        If True, it reduces the amount of data to process.
-        For L0A, it processes just the first 3 raw data files for each station.
-        For L0B, it processes just the first 100 rows of 3 L0A files for each station.
-        The default is False.
-    base_dir : str (optional)
-        Base directory of DISDRODB. Format: <...>/DISDRODB
-        If None (the default), the disdrodb config variable 'dir' is used.
+        The name of the station.
+    force : bool, optional
+        If ``True``, existing data in the destination directories will be overwritten.
+        If ``False`` (default), an error will be raised if data already exists in the destination directories.
+    verbose : bool, optional
+        If ``True`` (default), detailed processing information will be printed to the terminal.
+        If ``False``, less information will be displayed.
+    parallel : bool, optional
+        If ``True``, files will be processed in multiple processes simultaneously
+        with each process using a single thread.
+        If ``False`` (default), files will be processed sequentially in a single process,
+        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 3 raw data files will be processed. The default value is ``False``.
+    data_archive_dir : str, optional
+        The base directory of DISDRODB, expected in the format ``<...>/DISDRODB``.
+        If not specified, the path specified in the DISDRODB active configuration will be used.
     """
+    # Retrieve DISDRODB Metadata Archive and Data Archive root directories
+    data_archive_dir = get_data_archive_dir(data_archive_dir)
+    metadata_archive_dir = get_metadata_archive_dir(metadata_archive_dir)
+
+    # Read metadata
+    metadata = read_station_metadata(
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+    )
 
-    # ---------------------------------------------------------------------.
+    # ------------------------------------------------------------------------.
+    # Define raw data ingestion chain
+    # --> If raw data are netCDF files, this routine produces directly L0B files
+    # --> Otherwise, it produces L0A files.
+    if metadata["raw_data_format"] == "netcdf":
+        generate_standardized_files = _generate_l0b_from_nc
+        product = "L0B"
+    else:
+        generate_standardized_files = _generate_l0a
+        product = "L0A"
+
+    # ------------------------------------------------------------------------.
+    # Start product processing
     t_i = time.time()
-    msg = f"L0 processing of station {station_name} has started."
+    msg = f"{product} processing of station {station_name} has started."
     log_info(logger=logger, msg=msg, verbose=verbose)
 
-    # ------------------------------------------------------------------.
-    # L0A processing
-    if l0a_processing:
-        run_disdrodb_l0a_station(
-            # Station arguments
-            base_dir=base_dir,
-            data_source=data_source,
-            campaign_name=campaign_name,
-            station_name=station_name,
-            # Processing options
-            force=force,
-            verbose=verbose,
-            debugging_mode=debugging_mode,
-            parallel=parallel,
-        )
-    # ------------------------------------------------------------------.
-    # L0B processing
-    if l0b_processing:
-        run_disdrodb_l0b_station(
-            # Station arguments
-            base_dir=base_dir,
-            data_source=data_source,
-            campaign_name=campaign_name,
-            station_name=station_name,
-            # Processing options
-            force=force,
-            verbose=verbose,
-            debugging_mode=debugging_mode,
-            parallel=parallel,
-            remove_l0a=remove_l0a,
-        )
-
     # ------------------------------------------------------------------------.
-    # If l0b_concat=True, concat the netCDF in a single file
-    if l0b_concat:
-        run_disdrodb_l0b_concat_station(
-            base_dir=base_dir,
-            data_source=data_source,
-            campaign_name=campaign_name,
-            station_name=station_name,
-            remove_l0b=remove_l0b,
-            verbose=verbose,
-        )
+    # Create directory structure
+    data_dir = create_l0_directory_structure(
+        data_archive_dir=data_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        metadata_archive_dir=metadata_archive_dir,
+        product=product,  # L0A or L0B
+        station_name=station_name,
+        force=force,
+    )
 
     # -------------------------------------------------------------------------.
-    # End of L0 processing for all stations
-    timedelta_str = str(datetime.timedelta(seconds=time.time() - t_i))
-    msg = f"L0 processing of stations {station_name} completed in {timedelta_str}"
-    log_info(logger, msg, verbose)
-    return None
+    # Define logs directory
+    logs_dir = create_logs_directory(
+        product=product,
+        data_archive_dir=data_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+    )
 
+    # -----------------------------------------------------------------.
+    # Read issue YAML file
+    issue_dict = read_station_issue(
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+    )
 
-####---------------------------------------------------------------------------.
-#### Run L0 Archive processing
+    ##------------------------------------------------------------------------.
+    # Retrieve sensor name
+    sensor_name = metadata["sensor_name"]
+    check_sensor_name(sensor_name)
 
+    # Retrieve sensor name
+    reader_reference = metadata["reader"]
 
-def _check_available_stations(list_info):
-    # If no stations available, raise an error
-    if len(list_info) == 0:
-        msg = "No stations available given the provided `data_sources` and `campaign_names` arguments !"
-        raise ValueError(msg)
+    # Retrieve glob patterns
+    glob_pattern = metadata["raw_data_glob_pattern"]
 
+    ##------------------------------------------------------------------------.
+    # Retrieve reader
+    reader = get_reader(reader_reference, sensor_name=sensor_name)
 
-def _filter_list_info(list_info, station_names):
-    # Filter by provided stations
-    if station_names is not None:
-        list_info = [info for info in list_info if info[2] in station_names]
-        # If nothing left, raise an error
-        if len(list_info) == 0:
-            raise ValueError("No stations available given the provided `station_names` argument !")
-    return list_info
+    # -------------------------------------------------------------------------.
+    # List files to process
+    filepaths = find_files(
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+        product="RAW",
+        debugging_mode=debugging_mode,
+        data_archive_dir=data_archive_dir,
+        glob_pattern=glob_pattern,
+    )
 
+    # Print the number of files to be processed
+    n_files = len(filepaths)
+    msg = f"{n_files} raw files are ready to be processed."
+    log_info(logger=logger, msg=msg, verbose=verbose)
 
-def _get_starting_product(l0a_processing, l0b_processing):
-    if l0a_processing:
-        product = "RAW"
-    elif l0b_processing:
-        product = "L0A"
-    else:
-        raise ValueError("At least l0a_processing or l0b_processing must be True.")
-    return product
-
-
-def run_disdrodb_l0(
-    data_sources=None,
-    campaign_names=None,
-    station_names=None,
-    # L0 archive options
-    l0a_processing: bool = True,
-    l0b_processing: bool = True,
-    l0b_concat: bool = False,
+    # -----------------------------------------------------------------.
+    # Generate L0A/L0B files
+    # - Loop over the files and save the L0A Apache Parquet files.
+    # - If parallel=True, it does that in parallel using dask.delayed
+    list_tasks = [
+        generate_standardized_files(
+            filepath=filepath,
+            data_dir=data_dir,
+            logs_dir=logs_dir,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            # Reader argument
+            reader=reader,
+            # Processing info
+            metadata=metadata,
+            issue_dict=issue_dict,
+            # Processing options
+            force=force,
+            verbose=verbose,
+            parallel=parallel,
+        )
+        for filepath in filepaths
+    ]
+    list_logs = dask.compute(*list_tasks) if parallel else list_tasks
+
+    # -----------------------------------------------------------------.
+    # Define product summary logs
+    create_product_logs(
+        product=product,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+        data_archive_dir=data_archive_dir,
+        # Logs list
+        list_logs=list_logs,
+    )
+
+    # ---------------------------------------------------------------------.
+    # End product processing
+    timedelta_str = str(datetime.timedelta(seconds=round(time.time() - t_i)))
+    msg = f"{product} processing of station {station_name} completed in {timedelta_str}"
+    log_info(logger=logger, msg=msg, verbose=verbose)
+    # ---------------------------------------------------------------------.
+
+
+def run_l0b_station(
+    # Station arguments
+    data_source,
+    campaign_name,
+    station_name,
+    # L0B processing options
     remove_l0a: bool = False,
-    remove_l0b: bool = False,
     # Processing options
     force: bool = False,
-    verbose: bool = False,
-    debugging_mode: bool = False,
+    verbose: bool = True,
     parallel: bool = True,
-    base_dir: str = None,
+    debugging_mode: bool = False,
+    # DISDRODB root directories
+    data_archive_dir: Optional[str] = None,
+    metadata_archive_dir: Optional[str] = None,
 ):
-    """Run the L0 processing of DISDRODB stations.
+    """
+    Run the L0B processing of a specific DISDRODB station when invoked from the terminal.
 
-    This function allows to launch the processing of many DISDRODB stations with a single command.
-    From the list of all available DISDRODB stations, it runs the processing of the
-    stations matching the provided data_sources, campaign_names and station_names.
+    This function is intended to be called through the ``disdrodb_run_l0b_station``
+    command-line interface.
 
     Parameters
     ----------
-    data_sources : list
-        Name of data source(s) to process.
-        The name(s) must be UPPER CASE.
-        If campaign_names and station are not specified, process all stations.
-        The default is None
-    campaign_names : list
-        Name of the campaign(s) to process.
-        The name(s) must be UPPER CASE.
-        The default is None
-    station_names : list
-        Station names to process.
-        The default is None
-    l0a_processing : bool
-        Whether to launch processing to generate L0A Apache Parquet file(s) from raw data.
-        The default is True.
-    l0b_processing : bool
-        Whether to launch processing to generate L0B netCDF4 file(s) from L0A data.
-        The default is True.
-    l0b_concat : bool
-        Whether to concatenate all raw files into a single L0B netCDF file.
-        If l0b_concat=True, all raw files will be saved into a single L0B netCDF file.
-        If l0b_concat=False, each raw file will be converted into the corresponding L0B netCDF file.
-        The default is False.
-    remove_l0a : bool
-        Whether to keep the L0A files after having generated the L0B netCDF products.
-        The default is False.
-    remove_l0b : bool
-        Whether to remove the L0B files after having concatenated all L0B netCDF files.
-        It takes places only if l0b_concat = True
-        The default is False.
-    force : bool
-        If True, overwrite existing data into destination directories.
-        If False, raise an error if there are already data into destination directories.
-        The default is False.
-    verbose : bool
-        Whether to print detailed processing information into terminal.
-        The default is True.
-    parallel : bool
-        If True, the files are processed simultaneously in multiple processes.
-        Each process will use a single thread to avoid issues with the HDF/netCDF library.
-        By default, the number of process is defined with os.cpu_count().
-        If False, the files are processed sequentially in a single process.
-        If False, multi-threading is automatically exploited to speed up I/0 tasks.
-    debugging_mode : bool
-        If True, it reduces the amount of data to process.
-        For L0A, it processes just the first 3 raw data files.
-        For L0B, it processes just the first 100 rows of 3 L0A files.
-        The default is False.
-    base_dir : str (optional)
-        Base directory of DISDRODB. Format: <...>/DISDRODB
-        If None (the default), the disdrodb config variable 'dir' is used.
+    data_source : str
+        The name of the institution (for campaigns spanning multiple countries) or
+        the name of the country (for campaigns or sensor networks within a single country).
+        Must be provided in UPPER CASE.
+    campaign_name : str
+        The name of the campaign. Must be provided in UPPER CASE.
+    station_name : str
+        The name of the station.
+    force : bool, optional
+        If ``True``, existing data in the destination directories will be overwritten.
+        If ``False`` (default), an error will be raised if data already exists in the destination directories.
+    verbose : bool, optional
+        If ``True`` (default), detailed processing information will be printed to the terminal.
+        If ``False``, less information will be displayed.
+    parallel : bool, optional
+        If ``True``, files will be processed in multiple processes simultaneously,
+        with each process using a single thread to avoid issues with the HDF/netCDF library.
+        If ``False`` (default), files will be processed sequentially in a single process,
+        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``.
+    remove_l0a: bool, optional
+        Whether to remove the processed L0A files. The default value is ``False``.
+    data_archive_dir : str, optional
+        The base directory of DISDRODB, expected in the format ``<...>/DISDRODB``.
+        If not specified, the path specified in the DISDRODB active configuration will be used.
+
     """
-    from disdrodb.api.io import available_stations
+    # Define product
+    product = "L0B"
+
+    # Retrieve DISDRODB base directory
+    data_archive_dir = get_data_archive_dir(data_archive_dir)
+
+    # Retrieve DISDRODB Metadata Archive directory
+    metadata_archive_dir = get_metadata_archive_dir(metadata_archive_dir)
+
+    # -----------------------------------------------------------------.
+    # Retrieve metadata
+    metadata = read_station_metadata(
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+    )
+
+    # Skip run_l0b processing if the raw data are netCDFs
+    # - L0B produced when running L0A ...
+    if metadata["raw_data_format"] == "netcdf":
+        return
+
+    # -----------------------------------------------------------------.
+    # Start L0B processing
+    t_i = time.time()
+    msg = f"{product} processing of station_name {station_name} has started."
+    log_info(logger=logger, msg=msg, verbose=verbose)
 
-    # Get list of available stations
-    product = _get_starting_product(l0a_processing=l0a_processing, l0b_processing=l0b_processing)
-    list_info = available_stations(
-        base_dir=base_dir,
+    # -----------------------------------------------------------------.
+    # Define logs directory
+    logs_dir = create_logs_directory(
         product=product,
-        data_sources=data_sources,
-        campaign_names=campaign_names,
+        data_archive_dir=data_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
     )
-    _check_available_stations(list_info)
-    list_info = _filter_list_info(list_info, station_names)
-
-    # Print message
-    n_stations = len(list_info)
-    print(f"L0 processing of {n_stations} stations started.")
-
-    # Loop over stations
-    for data_source, campaign_name, station_name in list_info:
-        print(f"L0 processing of {data_source} {campaign_name} {station_name} station started.")
-        # Run processing
-        run_disdrodb_l0_station(
-            base_dir=base_dir,
+
+    # Create product directory
+    data_dir = create_product_directory(
+        data_archive_dir=data_archive_dir,
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+        product=product,
+        force=force,
+    )
+
+    ##----------------------------------------------------------------.
+    # Get L0A files for the station
+    required_product = get_required_product(product)
+    flag_not_available_data = False
+    try:
+        filepaths = find_files(
+            data_archive_dir=data_archive_dir,
             data_source=data_source,
             campaign_name=campaign_name,
             station_name=station_name,
-            # L0 archive options
-            l0a_processing=l0a_processing,
-            l0b_processing=l0b_processing,
-            l0b_concat=l0b_concat,
-            remove_l0a=remove_l0a,
-            remove_l0b=remove_l0b,
-            # Process options
+            product=required_product,
+            debugging_mode=debugging_mode,
+        )
+    except Exception as e:
+        print(str(e))  # Case where no file paths available
+        flag_not_available_data = True
+
+    # -------------------------------------------------------------------------.
+    # 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"has not been launched because of missing {required_product} data."
+        )
+        print(msg)
+        return
+
+    ##----------------------------------------------------------------.
+    # Generate L0B files
+    # Loop over the L0A files and save the L0B netCDF files.
+    # - If parallel=True, it does that in parallel using dask.bag
+    #   Settings npartitions=len(filepaths) enable to wait prior task on a core
+    #   finish before starting a new one.
+    # BUG: If debugging_mode=True and parallel=True a subtle bug can currently occur when
+    #   two processes with a subsetted L0A files want to create the same L0B files !
+    list_tasks = [
+        _generate_l0b(
+            filepath=filepath,
+            data_dir=data_dir,
+            logs_dir=logs_dir,
+            metadata=metadata,
+            campaign_name=campaign_name,
+            station_name=station_name,
             force=force,
             verbose=verbose,
             debugging_mode=debugging_mode,
             parallel=parallel,
         )
-        print(f"L0 processing of {data_source} {campaign_name} {station_name} station ended.")
+        for filepath in filepaths
+    ]
+    list_logs = dask.compute(*list_tasks) if parallel else list_tasks
+    # if not parallel:
+    #     list_logs = [
+    #         _generate_l0b(
+    #             filepath=filepath,
+    #             data_dir=data_dir,
+    #             logs_dir=logs_dir,
+    #             metadata=metadata,
+    #             campaign_name=campaign_name,
+    #             station_name=station_name,
+    #             force=force,
+    #             verbose=verbose,
+    #             debugging_mode=debugging_mode,
+    #             parallel=parallel,
+    #         )
+    #         for filepath in filepaths
+    #     ]
+
+    # else:
+    #     bag = db.from_sequence(filepaths, npartitions=len(filepaths))
+    #     list_logs = bag.map(
+    #         _generate_l0b,
+    #         data_dir=data_dir,
+    #         logs_dir=logs_dir,
+    #         metadata=metadata,
+    #         campaign_name=campaign_name,
+    #         station_name=station_name,
+    #         force=force,
+    #         verbose=verbose,
+    #         debugging_mode=debugging_mode,
+    #         parallel=parallel,
+    #     ).compute()
+
+    # -----------------------------------------------------------------.
+    # Define L0B summary logs
+    create_product_logs(
+        product=product,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+        data_archive_dir=data_archive_dir,
+        # Logs list
+        list_logs=list_logs,
+    )
+
+    # -----------------------------------------------------------------.
+    # End L0B processing
+    timedelta_str = str(datetime.timedelta(seconds=round(time.time() - t_i)))
+    msg = f"{product} processing of station_name {station_name} completed in {timedelta_str}"
+    log_info(logger=logger, msg=msg, verbose=verbose)
+
+    # -----------------------------------------------------------------.
+    # Option to remove L0A
+    if remove_l0a:
+        remove_product(
+            data_archive_dir=data_archive_dir,
+            product="L0A",
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            logger=logger,
+            verbose=verbose,
+        )
 
 
-def run_disdrodb_l0a(
-    data_sources=None,
-    campaign_names=None,
-    station_names=None,
+def run_l0c_station(
+    # Station arguments
+    data_source,
+    campaign_name,
+    station_name,
+    # L0C processing options
+    remove_l0b: bool = False,
     # Processing options
     force: bool = False,
-    verbose: bool = False,
-    debugging_mode: bool = False,
+    verbose: bool = True,
     parallel: bool = True,
-    base_dir: str = None,
+    debugging_mode: bool = False,
+    # DISDRODB root directories
+    data_archive_dir: Optional[str] = None,
+    metadata_archive_dir: Optional[str] = None,
 ):
-    """Run the L0A processing of DISDRODB stations.
+    """
+    Run the L0C processing of a specific DISDRODB station when invoked from the terminal.
+
+    The DISDRODB L0A and L0B routines just convert source raw data into netCDF format.
+    The DISDRODB L0C routine ingests L0B files and performs data homogenization.
+    The DISDRODB L0C routine takes care of:
+
+    - removing duplicated timesteps across files,
+    - merging/splitting files into daily files,
+    - regularizing timesteps for potentially trailing seconds,
+    - ensuring L0C files with unique sample intervals.
 
-    This function allows to launch the processing of many DISDRODB stations with a single command.
-    From the list of all available DISDRODB stations, it runs the processing of the
-    stations matching the provided data_sources, campaign_names and station_names.
+    Duplicated timesteps are automatically dropped if their variable values coincides,
+    otherwise an error is raised.
+
+    This function is intended to be called through the ``disdrodb_run_l0c_station``
+    command-line interface.
 
     Parameters
     ----------
-    data_sources : list
-        Name of data source(s) to process.
-        The name(s) must be UPPER CASE.
-        If campaign_names and station are not specified, process all stations.
-        The default is None
-    campaign_names : list
-        Name of the campaign(s) to process.
-        The name(s) must be UPPER CASE.
-        The default is None
-    station_names : list
-        Station names to process.
-        The default is None
-    force : bool
-        If True, overwrite existing data into destination directories.
-        If False, raise an error if there are already data into destination directories.
-        The default is False.
-    verbose : bool
-        Whether to print detailed processing information into terminal.
-        The default is True.
-    parallel : bool
-        If True, the files are processed simultaneously in multiple processes.
-        By default, the number of process is defined with os.cpu_count().
-        If False, the files are processed sequentially in a single process.
-    debugging_mode : bool
-        If True, it reduces the amount of data to process.
-        For L0A, it processes just the first 3 raw data files.
-        The default is False.
-    base_dir : str (optional)
-        Base directory of DISDRODB. Format: <...>/DISDRODB
-        If None (the default), the disdrodb config variable 'dir' is used.
+    data_source : str
+        The name of the institution (for campaigns spanning multiple countries) or
+        the name of the country (for campaigns or sensor networks within a single country).
+        Must be provided in UPPER CASE.
+    campaign_name : str
+        The name of the campaign. Must be provided in UPPER CASE.
+    station_name : str
+        The name of the station.
+    force : bool, optional
+        If ``True``, existing data in the destination directories will be overwritten.
+        If ``False`` (default), an error will be raised if data already exists in the destination directories.
+    verbose : bool, optional
+        If ``True`` (default), detailed processing information will be printed to the terminal.
+        If ``False``, less information will be displayed.
+    parallel : bool, optional
+        If ``True``, files will be processed in multiple processes simultaneously,
+        with each process using a single thread to avoid issues with the HDF/netCDF library.
+        If ``False`` (default), files will be processed sequentially in a single process,
+        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 3 files will be processed. The default value is ``False``.
+    remove_l0b: bool, optional
+        Whether to remove the processed L0B files. The default value is ``False``.
+    data_archive_dir : str, optional
+        The base directory of DISDRODB, expected in the format ``<...>/DISDRODB``.
+        If not specified, the path specified in the DISDRODB active configuration will be used.
+
     """
-    run_disdrodb_l0(
-        base_dir=base_dir,
-        data_sources=data_sources,
-        campaign_names=campaign_names,
-        station_names=station_names,
-        # L0 archive options
-        l0a_processing=True,
-        l0b_processing=False,
-        l0b_concat=False,
-        remove_l0a=False,
-        remove_l0b=False,
-        # Processing options
-        force=force,
-        verbose=verbose,
-        debugging_mode=debugging_mode,
-        parallel=parallel,
-    )
+    # Define product
+    product = "L0C"
 
+    # Define base directory
+    data_archive_dir = get_data_archive_dir(data_archive_dir)
 
-def run_disdrodb_l0b(
-    data_sources=None,
-    campaign_names=None,
-    station_names=None,
-    # Processing options
-    force: bool = False,
-    verbose: bool = False,
-    debugging_mode: bool = False,
-    parallel: bool = True,
-    base_dir: str = None,
-    remove_l0a: bool = False,
-):
-    run_disdrodb_l0(
-        base_dir=base_dir,
-        data_sources=data_sources,
-        campaign_names=campaign_names,
-        station_names=station_names,
-        # L0 archive options
-        l0a_processing=False,
-        l0b_processing=True,
-        l0b_concat=False,
-        remove_l0a=remove_l0a,
-        remove_l0b=False,
-        # Processing options
-        force=force,
-        verbose=verbose,
-        debugging_mode=debugging_mode,
-        parallel=parallel,
-    )
+    # Retrieve DISDRODB Metadata Archive directory
+    metadata_archive_dir = get_metadata_archive_dir(metadata_archive_dir)
 
+    # ------------------------------------------------------------------------.
+    # Start processing
+    t_i = time.time()
+    msg = f"{product} processing of station {station_name} has started."
+    log_info(logger=logger, msg=msg, verbose=verbose)
 
-####---------------------------------------------------------------------------.
-def run_disdrodb_l0b_concat(
-    data_sources=None,
-    campaign_names=None,
-    station_names=None,
-    remove_l0b=False,
-    verbose=False,
-    base_dir=None,
-):
-    """Concatenate the L0B files of the DISDRODB archive.
+    # ------------------------------------------------------------------------.
+    # Define logs directory
+    logs_dir = create_logs_directory(
+        product=product,
+        data_archive_dir=data_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+    )
 
-    This function is called by the ``disdrodb_run_l0b_concat`` script.
-    """
-    from disdrodb.api.io import available_stations
+    # Create product directory
+    data_dir = create_product_directory(
+        data_archive_dir=data_archive_dir,
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+        product=product,
+        force=force,
+    )
 
-    list_info = available_stations(
-        base_dir=base_dir,
-        product="L0B",
-        data_sources=data_sources,
-        campaign_names=campaign_names,
+    # ------------------------------------------------------------------------.
+    # Define metadata filepath
+    metadata_filepath = define_metadata_filepath(
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
     )
 
-    _check_available_stations(list_info)
-    list_info = _filter_list_info(list_info, station_names)
+    # -------------------------------------------------------------------------.
+    # List files to process
+    required_product = get_required_product(product)
+    flag_not_available_data = False
+    try:
+        filepaths = find_files(
+            data_archive_dir=data_archive_dir,
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            product=required_product,
+            # Processing options
+            debugging_mode=debugging_mode,
+        )
+    except Exception as e:
+        print(str(e))  # Case where no file paths available
+        flag_not_available_data = True
 
-    # Print message
-    n_stations = len(list_info)
-    print(f"Concatenation of {n_stations} L0B stations started.")
+    # -------------------------------------------------------------------------.
+    # 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"has not been launched because of missing {required_product} data."
+        )
+        print(msg)
+        return
 
-    # Start the loop to launch the concatenation of each station
-    for data_source, campaign_name, station_name in list_info:
-        print(f"L0B files concatenation of {data_source} {campaign_name} {station_name} station started.")
-        run_disdrodb_l0b_concat_station(
-            base_dir=base_dir,
-            data_source=data_source,
+    # -------------------------------------------------------------------------.
+    # Retrieve dictionary with the required files for each day.
+    dict_days_files = get_files_per_days(filepaths)
+
+    # -----------------------------------------------------------------.
+    # Generate L0C files
+    # - Loop over the L0 netCDF files and generate L1 files.
+    # - If parallel=True, it does that in parallel using dask.delayed
+    list_tasks = [
+        _generate_l0c(
+            day=day,
+            filepaths=filepaths,
+            data_dir=data_dir,
+            logs_dir=logs_dir,
+            metadata_filepath=metadata_filepath,
             campaign_name=campaign_name,
             station_name=station_name,
-            remove_l0b=remove_l0b,
+            # Processing options
+            force=force,
             verbose=verbose,
+            parallel=parallel,
         )
-    print(f"L0 files concatenation of {data_source} {campaign_name} {station_name} station ended.")
+        for day, filepaths in dict_days_files.items()
+    ]
+    list_logs = dask.compute(*list_tasks) if parallel else list_tasks
+
+    # -----------------------------------------------------------------.
+    # Define summary logs
+    create_product_logs(
+        product=product,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        station_name=station_name,
+        data_archive_dir=data_archive_dir,
+        # Logs list
+        list_logs=list_logs,
+    )
 
+    # ---------------------------------------------------------------------.
+    # End processing
+    timedelta_str = str(datetime.timedelta(seconds=round(time.time() - t_i)))
+    msg = f"{product} processing of station {station_name} completed in {timedelta_str}"
+    log_info(logger=logger, msg=msg, verbose=verbose)
 
-####---------------------------------------------------------------------------.
+    # -----------------------------------------------------------------.
+    # Option to remove L0B
+    if remove_l0b:
+        remove_product(
+            data_archive_dir=data_archive_dir,
+            product="L0B",
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            logger=logger,
+            verbose=verbose,
+        )