grdwindinversion 0.3.2__py3-none-any.whl → 0.3.5__py3-none-any.whl

grdwindinversion/inversion.py

@@ -1,6 +1,7 @@
+# To place here in the code to not have errors with cv2.
+#  if placed in main => error ..
 import tempfile
 import traceback
-
 import xsar
 import xsarsea
 from xsarsea import windspeed
@@ -9,17 +10,28 @@ import xarray as xr
 import numpy as np
 import sys
 import datetime
-import os
 import yaml
 from scipy.ndimage import binary_dilation
-
 import re
 import string
-import os
 from grdwindinversion.utils import check_incidence_range, get_pol_ratio_name, timing
 from grdwindinversion.load_config import getConf
-# optional debug messages
 import logging
+import os
+
+os.environ["OMP_NUM_THREADS"] = "1"
+os.environ["OPENBLAS_NUM_THREADS"] = "1"
+os.environ["MKL_NUM_THREADS"] = "1"
+os.environ["VECLIB_MAXIMUM_THREADS"] = "1"
+os.environ["NUMEXPR_NUM_THREADS"] = "1"
+try:
+    import cv2
+except:
+    import cv2
+cv2.setNumThreads(1)
+
+
+# optional debug messages
 logger = logging.getLogger('grdwindinversion.inversion')
 logger.addHandler(logging.NullHandler())
 
@@ -38,25 +50,28 @@ def getSensorMetaDataset(filename):
     tuple
         sensor name, sensor long name, meta function, dataset function
     """
-    if ("S1A" in filename):
+    if "S1A" in filename:
         return "S1A", "SENTINEL-1 A", xsar.Sentinel1Meta, xsar.Sentinel1Dataset
-    elif ("S1B" in filename):
+    elif "S1B" in filename:
         return "S1B", "SENTINEL-1 B", xsar.Sentinel1Meta, xsar.Sentinel1Dataset
-    elif ("RS2" in filename):
+    elif "RS2" in filename:
         return "RS2", "RADARSAT-2", xsar.RadarSat2Meta, xsar.RadarSat2Dataset
-    elif ("RCM1" in filename):
+    elif "RCM1" in filename:
         return "RCM", "RADARSAT Constellation 1", xsar.RcmMeta, xsar.RcmDataset
-    elif ("RCM2" in filename):
+    elif "RCM2" in filename:
         return "RCM", "RADARSAT Constellation 2", xsar.RcmMeta, xsar.RcmDataset
-    elif ("RCM3" in filename):
+    elif "RCM3" in filename:
         return "RCM", "RADARSAT Constellation 3", xsar.RcmMeta, xsar.RcmDataset
 
     else:
         raise ValueError(
-            "must be S1A|S1B|RS2|RCM1|RCM2|RCM3, got filename %s" % filename)
+            "must be S1A|S1B|RS2|RCM1|RCM2|RCM3, got filename %s" % filename
+        )
 
 
-def getOutputName2(input_file, outdir, sensor, meta, subdir=True):
+def getOutputName(
+    input_file, outdir, sensor, meta_start_date, meta_stop_date, subdir=True
+):
     """
     Create output filename for L2-GRD product
 
@@ -68,8 +83,10 @@ def getOutputName2(input_file, outdir, sensor, meta, subdir=True):
         output folder
     sensor : str
         sensor name
-    meta : obj `xsar.BaseMeta` (one of the supported SAR mission)
-        meta object
+    start_date : str
+        start date
+    stop_date : str
+        stop date
 
     Returns
     -------
@@ -78,33 +95,68 @@ def getOutputName2(input_file, outdir, sensor, meta, subdir=True):
     """
     basename = os.path.basename(input_file)
     basename_match = basename
-    meta_start_date = meta.start_date.split(".")[0].replace(
-        "-", "").replace(":", "").replace(" ", "t").replace("Z", "")
-    meta_stop_date = meta.stop_date.split(".")[0].replace(
-        "-", "").replace(":", "").replace(" ", "t").replace("Z", "")
 
-    if sensor == 'S1A' or sensor == 'S1B':
+    if sensor == "S1A" or sensor == "S1B":
         regex = re.compile(
-            "(...)_(..)_(...)(.)_(.)(.)(..)_(........T......)_(........T......)_(......)_(......)_(....).SAFE")
+            "(...)_(..)_(...)(.)_(.)(.)(..)_(........T......)_(........T......)_(......)_(......)_(....).SAFE"
+        )
         template = string.Template(
-            "${MISSIONID}_${BEAM}_${PRODUCT}${RESOLUTION}_${LEVEL}${CLASS}${POL}_${STARTDATE}_${STOPDATE}_${ORBIT}_${TAKEID}_${PRODID}.SAFE")
+            "${MISSIONID}_${BEAM}_${PRODUCT}${RESOLUTION}_${LEVEL}${CLASS}${POL}_${STARTDATE}_${STOPDATE}_${ORBIT}_${TAKEID}_${PRODID}.SAFE"
+        )
         match = regex.match(basename_match)
-        MISSIONID, BEAM, PRODUCT, RESOLUTION, LEVEL, CLASS, POL, STARTDATE, STOPDATE, ORBIT, TAKEID, PRODID = match.groups()
+        if not match:
+            raise AttributeError(
+                f"S1 file {basename_match} does not match the expected pattern"
+            )
+
+        (
+            MISSIONID,
+            BEAM,
+            PRODUCT,
+            RESOLUTION,
+            LEVEL,
+            CLASS,
+            POL,
+            STARTDATE,
+            STOPDATE,
+            ORBIT,
+            TAKEID,
+            PRODID,
+        ) = match.groups()
         new_format = f"{MISSIONID.lower()}-{BEAM.lower()}-owi-xx-{STARTDATE.lower()}-{STOPDATE.lower()}-{ORBIT}-{TAKEID}.nc"
-    elif sensor == 'RS2':
+    elif sensor == "RS2":
         regex = re.compile(
-            "(RS2)_OK([0-9]+)_PK([0-9]+)_DK([0-9]+)_(....)_(........)_(......)_(.._?.?.?)_(S.F)")
+            "(RS2)_OK([0-9]+)_PK([0-9]+)_DK([0-9]+)_(....)_(........)_(......)_(.._?.?.?)_(S.F)"
+        )
         template = string.Template(
-            "${MISSIONID}_OK${DATA1}_PK${DATA2}_DK${DATA3}_${DATA4}_${DATE}_${TIME}_${POLARIZATION}_${LAST}")
+            "${MISSIONID}_OK${DATA1}_PK${DATA2}_DK${DATA3}_${DATA4}_${DATE}_${TIME}_${POLARIZATION}_${LAST}"
+        )
         match = regex.match(basename_match)
-        MISSIONID, DATA1, DATA2, DATA3, DATA4, DATE, TIME, POLARIZATION, LAST = match.groups()
+        if not match:
+            raise AttributeError(
+                f"RC2 file {basename_match} does not match the expected pattern"
+            )
+
+        MISSIONID, DATA1, DATA2, DATA3, DATA4, DATE, TIME, POLARIZATION, LAST = (
+            match.groups()
+        )
         new_format = f"{MISSIONID.lower()}--owi-xx-{meta_start_date.lower()}-{meta_stop_date.lower()}-_____-_____.nc"
-    elif sensor == 'RCM':
+    elif sensor == "RCM":
+
         regex = re.compile(
-            r"(RCM[0-9])_OK([0-9]+)_PK([0-9]+)_([0-9]+)_([A-Z]+)_(\d{8})_(\d{6})_([A-Z]{2}(?:_[A-Z]{2})?)_([A-Z]+)$")
+            r"(RCM[0-9])_OK([0-9]+)_PK([0-9]+)_([0-9]+)_([A-Z0-9]+)_(\d{8})_(\d{6})_([A-Z]{2}(?:_[A-Z]{2})?)_([A-Z]+)$"
+        )
         match = regex.match(basename_match)
-        MISSIONID, DATA1, DATA2, DATA3, BEAM, DATE, TIME, POLARIZATION, PRODUCT = match.groups()
+        if not match:
+            raise AttributeError(
+                f"RCM file {basename_match} does not match the expected pattern"
+            )
+
+        MISSIONID, DATA1, DATA2, DATA3, BEAM, DATE, TIME, POLARIZATION, PRODUCT = (
+            match.groups()
+        )
         new_format = f"{MISSIONID.lower()}-{BEAM.lower()}-owi-xx-{meta_start_date.lower()}-{meta_stop_date.lower()}-_____-_____.nc"
+
     else:
         raise ValueError(
             "sensor must be S1A|S1B|RS2|RCM, got sensor %s" % sensor)
@@ -116,7 +168,7 @@ def getOutputName2(input_file, outdir, sensor, meta, subdir=True):
     return out_file
 
 
-def getAncillary(meta, ancillary_name='ecmwf'):
+def getAncillary(meta, ancillary_name="ecmwf"):
     """
     Map ancillary wind from ECMWF or ERA5.
     This function is used to check if the model files are available and to map the model to the SAR data.
@@ -131,28 +183,34 @@ def getAncillary(meta, ancillary_name='ecmwf'):
         map model to SAR data
     """
 
-    if ancillary_name == 'ecmwf':
+    if ancillary_name == "ecmwf":
 
-        logging.debug('conf: %s', getConf())
-        ec01 = getConf()['ecmwf_0100_1h']
-        ec0125 = getConf()['ecmwf_0125_1h']
-        logging.debug('ec01 : %s', ec01)
-        meta.set_raster('ecmwf_0100_1h', ec01)
-        meta.set_raster('ecmwf_0125_1h', ec0125)
+        logging.debug("conf: %s", getConf())
+        ec01 = getConf()["ecmwf_0100_1h"]
+        ec0125 = getConf()["ecmwf_0125_1h"]
+        logging.debug("ec01 : %s", ec01)
+        meta.set_raster("ecmwf_0100_1h", ec01)
+        meta.set_raster("ecmwf_0125_1h", ec0125)
 
         map_model = None
         # only keep best ecmwf  (FIXME: it's hacky, and xsar should provide a better method to handle this)
-        for ecmwf_name in ['ecmwf_0125_1h', 'ecmwf_0100_1h']:
+        for ecmwf_name in ["ecmwf_0125_1h", "ecmwf_0100_1h"]:
             ecmwf_infos = meta.rasters.loc[ecmwf_name]
             try:
-                ecmwf_file = ecmwf_infos['get_function'](ecmwf_infos['resource'],
-                                                         date=datetime.datetime.strptime(meta.start_date,
-                                                                                         '%Y-%m-%d %H:%M:%S.%f'))[1]
+                ecmwf_file = ecmwf_infos["get_function"](
+                    ecmwf_infos["resource"],
+                    date=datetime.datetime.strptime(
+                        meta.start_date, "%Y-%m-%d %H:%M:%S.%f"
+                    ),
+                )[1]
             # temporary for RCM issue https://github.com/umr-lops/xarray-safe-rcm/issues/34
             except Exception as e:
-                ecmwf_file = ecmwf_infos['get_function'](ecmwf_infos['resource'],
-                                                         date=datetime.datetime.strptime(meta.start_date,
-                                                                                         '%Y-%m-%d %H:%M:%S'))[1]
+                ecmwf_file = ecmwf_infos["get_function"](
+                    ecmwf_infos["resource"],
+                    date=datetime.datetime.strptime(
+                        meta.start_date, "%Y-%m-%d %H:%M:%S"
+                    ),
+                )[1]
             if not os.path.isfile(ecmwf_file):
                 # temporary
                 # if repro does not exist we look at not repro folder (only one will exist after)
@@ -179,41 +237,58 @@ def getAncillary(meta, ancillary_name='ecmwf'):
                 """
                 meta.rasters = meta.rasters.drop([ecmwf_name])
             else:
-                map_model = {'%s_%s' % (ecmwf_name, uv): 'model_%s' %
-                             uv for uv in ['U10', 'V10']}
+                map_model = {
+                    "%s_%s" % (ecmwf_name, uv): "model_%s" % uv for uv in ["U10", "V10"]
+                }
 
         return map_model
 
-    elif ancillary_name == 'era5':
+    elif ancillary_name == "era5":
         era5_name = "era5_0250_1h"
-        logging.debug('conf: %s', getConf())
+        logging.debug("conf: %s", getConf())
         era0250 = getConf()[era5_name]
-        logging.debug('%s : %s', (era5_name, era0250))
+        logging.debug("%s : %s", (era5_name, era0250))
         meta.set_raster(era5_name, era0250)
 
         era5_infos = meta.rasters.loc[era5_name]
         try:
-            era5_file = era5_infos['get_function'](era5_infos['resource'],
-                                                   date=datetime.datetime.strptime(meta.start_date,
-                                                                                   '%Y-%m-%d %H:%M:%S.%f'))[1]
+            era5_file = era5_infos["get_function"](
+                era5_infos["resource"],
+                date=datetime.datetime.strptime(
+                    meta.start_date, "%Y-%m-%d %H:%M:%S.%f"
+                ),
+            )[1]
         except Exception as e:
-            era5_file = era5_infos['get_function'](era5_infos['resource'],
-                                                   date=datetime.datetime.strptime(meta.start_date,
-                                                                                   '%Y-%m-%d %H:%M:%S'))[1]
+            era5_file = era5_infos["get_function"](
+                era5_infos["resource"],
+                date=datetime.datetime.strptime(
+                    meta.start_date, "%Y-%m-%d %H:%M:%S"),
+            )[1]
         if not os.path.isfile(era5_file):
             raise ValueError(f"era5 file {era5_file} not found")
 
-        map_model = {'%s_%s' % (era5_name, uv): 'model_%s' %
-                     uv for uv in ['U10', 'V10']}
+        map_model = {
+            "%s_%s" % (era5_name, uv): "model_%s" % uv for uv in ["U10", "V10"]
+        }
         return map_model
 
     else:
-        raise ValueError("ancillary_name must be ecmwf/era5, got %s" %
-                         ancillary_name)
+        raise ValueError(
+            "ancillary_name must be ecmwf/era5, got %s" % ancillary_name)
 
 
 @timing(logger=logger.debug)
-def inverse(dual_pol, inc, sigma0, sigma0_dual, ancillary_wind, dsig_cr, model_co, model_cross, **kwargs):
+def inverse(
+    dual_pol,
+    inc,
+    sigma0,
+    sigma0_dual,
+    ancillary_wind,
+    dsig_cr,
+    model_co,
+    model_cross,
+    **kwargs,
+):
     """
     Invert sigma0 to retrieve wind using model (lut or gmf).
 
@@ -251,14 +326,19 @@ def inverse(dual_pol, inc, sigma0, sigma0_dual, ancillary_wind, dsig_cr, model_c
     """
     logging.debug("inversion")
 
-    list_mods = windspeed.available_models().index.tolist(
-    ) + windspeed.available_models().alias.tolist() + [None]
+    list_mods = (
+        windspeed.available_models().index.tolist()
+        + windspeed.available_models().alias.tolist()
+        + [None]
+    )
     if model_co not in list_mods:
         raise ValueError(
-            f"model_co {model_co} not in windspeed.available_models() : not going further")
+            f"model_co {model_co} not in windspeed.available_models() : not going further"
+        )
     if model_cross not in list_mods:
         raise ValueError(
-            f"model_cross {model_cross} not in windspeed.available_models() : not going further")
+            f"model_cross {model_cross} not in windspeed.available_models() : not going further"
+        )
 
     winds = windspeed.invert_from_model(
         inc,
@@ -267,7 +347,8 @@ def inverse(dual_pol, inc, sigma0, sigma0_dual, ancillary_wind, dsig_cr, model_c
         ancillary_wind=ancillary_wind,
         dsig_cr=dsig_cr,
         model=(model_co, model_cross),
-        **kwargs)
+        **kwargs,
+    )
 
     if dual_pol:
         wind_co, wind_dual = winds
@@ -277,7 +358,8 @@ def inverse(dual_pol, inc, sigma0, sigma0_dual, ancillary_wind, dsig_cr, model_c
             sigma0_dual.values,
             dsig_cr=dsig_cr.values,
             model=model_cross,
-            **kwargs)
+            **kwargs,
+        )
 
         return wind_co, wind_dual, wind_cross
     else:
@@ -309,38 +391,42 @@ def makeL2asOwi(xr_dataset, config):
     --------
     """
 
-    xr_dataset = xr_dataset.rename({
-        'longitude': 'owiLon',
-        'latitude': 'owiLat',
-        'incidence': 'owiIncidenceAngle',
-        'elevation': 'owiElevationAngle',
-        'ground_heading': 'owiHeading',
-        'land_mask': 'owiLandFlag',
-        'mask': 'owiMask',
-        'windspeed_co': 'owiWindSpeed_co',
-        'winddir_co': 'owiWindDirection_co',
-        'ancillary_wind_speed': 'owiAncillaryWindSpeed',
-        'ancillary_wind_direction': 'owiAncillaryWindDirection',
-        'sigma0_detrend': 'owiNrcs_detrend',
-    })
+    xr_dataset = xr_dataset.rename(
+        {
+            "longitude": "owiLon",
+            "latitude": "owiLat",
+            "incidence": "owiIncidenceAngle",
+            "elevation": "owiElevationAngle",
+            "ground_heading": "owiHeading",
+            "land_mask": "owiLandFlag",
+            "mask": "owiMask",
+            "windspeed_co": "owiWindSpeed_co",
+            "winddir_co": "owiWindDirection_co",
+            "ancillary_wind_speed": "owiAncillaryWindSpeed",
+            "ancillary_wind_direction": "owiAncillaryWindDirection",
+            "sigma0_detrend": "owiNrcs_detrend",
+        }
+    )
 
     if "offboresight" in xr_dataset:
         xr_dataset = xr_dataset.rename(
             {"offboresight": "owiOffboresightAngle"})
 
     if config["add_nrcs_model"]:
-        xr_dataset = xr_dataset.rename(
-            {"ancillary_nrcs": "owiAncillaryNrcs"})
+        xr_dataset = xr_dataset.rename({"ancillary_nrcs": "owiAncillaryNrcs"})
         xr_dataset.owiAncillaryNrcs.attrs["units"] = "m^2 / m^2"
-        xr_dataset.owiAncillaryNrcs.attrs[
-            "long_name"] = f"Ancillary Normalized Radar Cross Section - simulated from {config['l2_params']['copol_gmf']} & ancillary wind"
+        xr_dataset.owiAncillaryNrcs.attrs["long_name"] = (
+            f"Ancillary Normalized Radar Cross Section - simulated from {config['l2_params']['copol_gmf']} & ancillary wind"
+        )
 
         if config["l2_params"]["dual_pol"]:
             xr_dataset = xr_dataset.rename(
-                {"ancillary_nrcs_cross": "owiAncillaryNrcs_cross"})
+                {"ancillary_nrcs_cross": "owiAncillaryNrcs_cross"}
+            )
             xr_dataset.owiAncillaryNrcs_cross.attrs["units"] = "m^2 / m^2"
-            xr_dataset.owiAncillaryNrcs_cross.attrs[
-                "long_name"] = f"Ancillary Normalized Radar Cross Section - simulated from {config['l2_params']['crosspol_gmf']} & ancillary wind"
+            xr_dataset.owiAncillaryNrcs_cross.attrs["long_name"] = (
+                f"Ancillary Normalized Radar Cross Section - simulated from {config['l2_params']['crosspol_gmf']} & ancillary wind"
+            )
 
     xr_dataset.owiLon.attrs["units"] = "degrees_east"
     xr_dataset.owiLon.attrs["long_name"] = "Longitude at wind cell center"
@@ -351,146 +437,196 @@ def makeL2asOwi(xr_dataset, config):
     xr_dataset.owiLat.attrs["standard_name"] = "latitude"
 
     xr_dataset.owiIncidenceAngle.attrs["units"] = "degrees"
-    xr_dataset.owiIncidenceAngle.attrs["long_name"] = "Incidence angle at wind cell center"
+    xr_dataset.owiIncidenceAngle.attrs["long_name"] = (
+        "Incidence angle at wind cell center"
+    )
     xr_dataset.owiIncidenceAngle.attrs["standard_name"] = "incidence"
 
     xr_dataset.owiElevationAngle.attrs["units"] = "degrees"
-    xr_dataset.owiElevationAngle.attrs["long_name"] = "Elevation angle at wind cell center"
+    xr_dataset.owiElevationAngle.attrs["long_name"] = (
+        "Elevation angle at wind cell center"
+    )
     xr_dataset.owiElevationAngle.attrs["standard_name"] = "elevation"
 
-    xr_dataset['owiNrcs'] = xr_dataset['sigma0_ocean'].sel(
-        pol=config["l2_params"]["copol"])
+    xr_dataset["owiNrcs"] = xr_dataset["sigma0_ocean"].sel(
+        pol=config["l2_params"]["copol"]
+    )
     xr_dataset.owiNrcs.attrs = xr_dataset.sigma0_ocean.attrs
-    xr_dataset.owiNrcs.attrs['units'] = 'm^2 / m^2'
-    xr_dataset.owiNrcs.attrs['long_name'] = 'Normalized Radar Cross Section'
-    xr_dataset.owiNrcs.attrs['definition'] = 'owiNrcs_no_noise_correction - owiNesz'
+    xr_dataset.owiNrcs.attrs["units"] = "m^2 / m^2"
+    xr_dataset.owiNrcs.attrs["long_name"] = "Normalized Radar Cross Section"
+    xr_dataset.owiNrcs.attrs["definition"] = "owiNrcs_no_noise_correction - owiNesz"
 
-    xr_dataset['owiMask_Nrcs'] = xr_dataset['sigma0_mask'].sel(
-        pol=config["l2_params"]["copol"])
+    xr_dataset["owiMask_Nrcs"] = xr_dataset["sigma0_mask"].sel(
+        pol=config["l2_params"]["copol"]
+    )
     xr_dataset.owiMask_Nrcs.attrs = xr_dataset.sigma0_mask.attrs
 
     # NESZ & DSIG
     xr_dataset = xr_dataset.assign(
-        owiNesz=(['line', 'sample'], xr_dataset.nesz.sel(pol=config["l2_params"]["copol"]).values))
-    xr_dataset.owiNesz.attrs['units'] = 'm^2 / m^2'
-    xr_dataset.owiNesz.attrs['long_name'] = 'Noise Equivalent SigmaNaught'
+        owiNesz=(
+            ["line", "sample"],
+            xr_dataset.nesz.sel(pol=config["l2_params"]["copol"]).values,
+        )
+    )
+    xr_dataset.owiNesz.attrs["units"] = "m^2 / m^2"
+    xr_dataset.owiNesz.attrs["long_name"] = "Noise Equivalent SigmaNaught"
 
-    xr_dataset['owiNrcs_no_noise_correction'] = xr_dataset['sigma0_ocean_raw'].sel(
-        pol=config["l2_params"]["copol"])
+    xr_dataset["owiNrcs_no_noise_correction"] = xr_dataset["sigma0_ocean_raw"].sel(
+        pol=config["l2_params"]["copol"]
+    )
     xr_dataset.owiNrcs_no_noise_correction.attrs = xr_dataset.sigma0_ocean_raw.attrs
-    xr_dataset.owiNrcs_no_noise_correction.attrs['units'] = 'm^2 / m^2'
-    xr_dataset.owiNrcs_no_noise_correction.attrs[
-        'long_name'] = 'Normalized Radar Cross Section ; no noise correction applied'
-    xr_dataset.owiNrcs_no_noise_correction.attrs[
-        'comment'] = 'owiNrcs_no_noise_correction ; no recalibration'
+    xr_dataset.owiNrcs_no_noise_correction.attrs["units"] = "m^2 / m^2"
+    xr_dataset.owiNrcs_no_noise_correction.attrs["long_name"] = (
+        "Normalized Radar Cross Section ; no noise correction applied"
+    )
+    xr_dataset.owiNrcs_no_noise_correction.attrs["comment"] = (
+        "owiNrcs_no_noise_correction ; no recalibration"
+    )
 
-    if 'swath_number' in xr_dataset:
-        xr_dataset = xr_dataset.rename({
-            'swath_number': 'owiSwathNumber',
-            'swath_number_flag': 'owiSwathNumberFlag'
-        })
+    if "swath_number" in xr_dataset:
+        xr_dataset = xr_dataset.rename(
+            {
+                "swath_number": "owiSwathNumber",
+                "swath_number_flag": "owiSwathNumberFlag",
+            }
+        )
 
         xr_dataset["owiSwathNumber"].attrs["standart_name"] = "swath number"
 
     # sigma0_raw__corrected cross
     if "sigma0_raw__corrected" in xr_dataset:
-        xr_dataset['owiNrcs_no_noise_correction_recalibrated'] = xr_dataset['sigma0_raw__corrected'].sel(
-            pol=config["l2_params"]["copol"])
-        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs = xr_dataset.sigma0_raw__corrected.attrs
-        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs['units'] = 'm^2 / m^2'
-        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs[
-            'long_name'] = 'Normalized Radar Cross Section, no noise correction applied'
-        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs[
-            'comment'] = 'owiNrcs_no_noise_correction ; recalibrated with kersten method'
+        xr_dataset["owiNrcs_no_noise_correction_recalibrated"] = xr_dataset[
+            "sigma0_raw__corrected"
+        ].sel(pol=config["l2_params"]["copol"])
+        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs = (
+            xr_dataset.sigma0_raw__corrected.attrs
+        )
+        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs["units"] = "m^2 / m^2"
+        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs["long_name"] = (
+            "Normalized Radar Cross Section, no noise correction applied"
+        )
+        xr_dataset.owiNrcs_no_noise_correction_recalibrated.attrs["comment"] = (
+            "owiNrcs_no_noise_correction ; recalibrated with kersten method"
+        )
 
-        xr_dataset.owiNrcs.attrs['definition'] = 'owiNrcs_no_noise_correction_recalibrated - owiNesz'
+        xr_dataset.owiNrcs.attrs["definition"] = (
+            "owiNrcs_no_noise_correction_recalibrated - owiNesz"
+        )
 
     if config["l2_params"]["dual_pol"]:
-
         xr_dataset = xr_dataset.rename({
             'dsig_cross': 'owiDsig_cross',
             'winddir_cross': 'owiWindDirection_cross',
             'winddir_dual': 'owiWindDirection',
             'windspeed_cross': 'owiWindSpeed_cross',
             'windspeed_dual': 'owiWindSpeed',
-            'sigma0_detrend_cross': 'owiNrcs_detrend_cross'
+            'sigma0_detrend_cross': 'owiNrcs_detrend_cross',
+            'nesz_cross_flattened': 'owiNesz_cross_flattened'
         })
 
-        if config["apply_flattening"]:
-            xr_dataset = xr_dataset.rename({
-                'nesz_cross_flattened': 'owiNesz_cross_flattened',
-            })
-
         # nrcs cross
-        xr_dataset['owiNrcs_cross'] = xr_dataset['sigma0_ocean'].sel(
-            pol=config["l2_params"]["crosspol"])
+        xr_dataset["owiNrcs_cross"] = xr_dataset["sigma0_ocean"].sel(
+            pol=config["l2_params"]["crosspol"]
+        )
 
-        xr_dataset.owiNrcs_cross.attrs['units'] = 'm^2 / m^2'
-        xr_dataset.owiNrcs_cross.attrs['long_name'] = 'Normalized Radar Cross Section'
-        xr_dataset.owiNrcs_cross.attrs['definition'] = 'owiNrcs_cross_no_noise_correction - owiNesz_cross'
+        xr_dataset.owiNrcs_cross.attrs["units"] = "m^2 / m^2"
+        xr_dataset.owiNrcs_cross.attrs["long_name"] = "Normalized Radar Cross Section"
+        xr_dataset.owiNrcs_cross.attrs["definition"] = (
+            "owiNrcs_cross_no_noise_correction - owiNesz_cross"
+        )
 
-        xr_dataset['owiMask_Nrcs_cross'] = xr_dataset['sigma0_mask'].sel(
-            pol=config["l2_params"]["crosspol"])
+        xr_dataset["owiMask_Nrcs_cross"] = xr_dataset["sigma0_mask"].sel(
+            pol=config["l2_params"]["crosspol"]
+        )
         xr_dataset.owiMask_Nrcs_cross.attrs = xr_dataset.sigma0_mask.attrs
 
         # nesz cross
-        xr_dataset = xr_dataset.assign(owiNesz_cross=(
-            ['line', 'sample'], xr_dataset.nesz.sel(pol=config["l2_params"]["crosspol"]).values))  # no flattening
-        xr_dataset.owiNesz_cross.attrs['units'] = 'm^2 / m^2'
-        xr_dataset.owiNesz_cross.attrs['long_name'] = 'Noise Equivalent SigmaNaught'
+        xr_dataset = xr_dataset.assign(
+            owiNesz_cross=(
+                ["line", "sample"],
+                xr_dataset.nesz.sel(
+                    pol=config["l2_params"]["crosspol"]).values,
+            )
+        )  # no flattening
+        xr_dataset.owiNesz_cross.attrs["units"] = "m^2 / m^2"
+        xr_dataset.owiNesz_cross.attrs["long_name"] = "Noise Equivalent SigmaNaught"
+
+        xr_dataset.owiNesz_cross_flattened.attrs["units"] = "m^2 / m^2"
+        xr_dataset.owiNesz_cross_flattened.attrs["long_name"] = "Noise Equivalent SigmaNaught"
 
-        xr_dataset['owiNrcs_cross_no_noise_correction'] = xr_dataset['sigma0_ocean_raw'].sel(
-            pol=config["l2_params"]["crosspol"])
+        xr_dataset["owiNrcs_cross_no_noise_correction"] = xr_dataset[
+            "sigma0_ocean_raw"
+        ].sel(pol=config["l2_params"]["crosspol"])
 
-        xr_dataset.owiNrcs_cross_no_noise_correction.attrs['units'] = 'm^2 / m^2'
-        xr_dataset.owiNrcs_cross_no_noise_correction.attrs[
-            'long_name'] = 'Normalized Radar Cross Section, no noise correction applied'
+        xr_dataset.owiNrcs_cross_no_noise_correction.attrs["units"] = "m^2 / m^2"
+        xr_dataset.owiNrcs_cross_no_noise_correction.attrs["long_name"] = (
+            "Normalized Radar Cross Section, no noise correction applied"
+        )
 
         #  sigma0_raw__corrected cross
         if "sigma0_raw__corrected" in xr_dataset:
-            xr_dataset['owiNrcs_cross_no_noise_correction_recalibrated'] = xr_dataset['sigma0_raw__corrected'].sel(
-                pol=config["l2_params"]["crosspol"])
-            xr_dataset.owiNrcs_cross_no_noise_correction_recalibrated.attrs = xr_dataset.sigma0_raw__corrected.attrs
-            xr_dataset.owiNrcs_cross_no_noise_correction_recalibrated.attrs['units'] = 'm^2 / m^2'
+            xr_dataset["owiNrcs_cross_no_noise_correction_recalibrated"] = xr_dataset[
+                "sigma0_raw__corrected"
+            ].sel(pol=config["l2_params"]["crosspol"])
+            xr_dataset.owiNrcs_cross_no_noise_correction_recalibrated.attrs = (
+                xr_dataset.sigma0_raw__corrected.attrs
+            )
+            xr_dataset.owiNrcs_cross_no_noise_correction_recalibrated.attrs["units"] = (
+                "m^2 / m^2"
+            )
             xr_dataset.owiNrcs_cross_no_noise_correction_recalibrated.attrs[
-                'long_name'] = 'Normalized Radar Cross Section ; no noise correction applied'
+                "long_name"
+            ] = "Normalized Radar Cross Section ; no noise correction applied"
             xr_dataset.owiNrcs_cross_no_noise_correction_recalibrated.attrs[
-                'comment'] = 'owiNrcs_cross_no_noise_correction ; recalibrated with kersten method'
+                "comment"
+            ] = "owiNrcs_cross_no_noise_correction ; recalibrated with kersten method"
 
-            xr_dataset.owiNrcs_cross.attrs['definition'] = 'owiNrcs_cross_no_noise_correction_recalibrated - owiNesz_cross'
+            xr_dataset.owiNrcs_cross.attrs["definition"] = (
+                "owiNrcs_cross_no_noise_correction_recalibrated - owiNesz_cross"
+            )
 
     if config["add_gradientsfeatures"]:
-        xr_dataset = xr_dataset.rename({
-            'heterogeneity_mask': 'owiWindFilter'
-        })
+        xr_dataset = xr_dataset.rename({"heterogeneity_mask": "owiWindFilter"})
     else:
-        xr_dataset['owiWindFilter'] = xr.full_like(xr_dataset.owiNrcs, 0)
-        xr_dataset['owiWindFilter'].attrs['long_name'] = "Quality flag taking into account the local heterogeneity"
-        xr_dataset['owiWindFilter'].attrs['valid_range'] = np.array([0, 3])
-        xr_dataset['owiWindFilter'].attrs['flag_values'] = np.array([
-            0, 1, 2, 3])
-        xr_dataset['owiWindFilter'].attrs[
-            'flag_meanings'] = "homogeneous_NRCS, heterogeneous_from_co-polarization_NRCS, heterogeneous_from_cross-polarization_NRCS, heterogeneous_from_dual-polarization_NRCS"
+        xr_dataset["owiWindFilter"] = xr.full_like(xr_dataset.owiNrcs, 0)
+        xr_dataset["owiWindFilter"].attrs[
+            "long_name"
+        ] = "Quality flag taking into account the local heterogeneity"
+        xr_dataset["owiWindFilter"].attrs["valid_range"] = np.array([0, 3])
+        xr_dataset["owiWindFilter"].attrs["flag_values"] = np.array([
+                                                                    0, 1, 2, 3])
+        xr_dataset["owiWindFilter"].attrs[
+            "flag_meanings"
+        ] = "homogeneous_NRCS, heterogeneous_from_co-polarization_NRCS, heterogeneous_from_cross-polarization_NRCS, heterogeneous_from_dual-polarization_NRCS"
 
     #  other variables
 
-    xr_dataset['owiWindQuality'] = xr.full_like(xr_dataset.owiNrcs, 0)
-    xr_dataset['owiWindQuality'].attrs[
-        'long_name'] = "Quality flag taking into account the consistency_between_wind_inverted_and_NRCS_and_Doppler_measured"
-    xr_dataset['owiWindQuality'].attrs['valid_range'] = np.array([0, 3])
-    xr_dataset['owiWindQuality'].attrs['flag_values'] = np.array([
-        0, 1, 2, 3])
-    xr_dataset['owiWindQuality'].attrs['flag_meanings'] = "good medium low poor"
-    xr_dataset['owiWindQuality'].attrs['comment'] = 'NOT COMPUTED YET'
+    xr_dataset["owiWindQuality"] = xr.full_like(xr_dataset.owiNrcs, 0)
+    xr_dataset["owiWindQuality"].attrs[
+        "long_name"
+    ] = "Quality flag taking into account the consistency_between_wind_inverted_and_NRCS_and_Doppler_measured"
+    xr_dataset["owiWindQuality"].attrs["valid_range"] = np.array([0, 3])
+    xr_dataset["owiWindQuality"].attrs["flag_values"] = np.array([0, 1, 2, 3])
+    xr_dataset["owiWindQuality"].attrs["flag_meanings"] = "good medium low poor"
+    xr_dataset["owiWindQuality"].attrs["comment"] = "NOT COMPUTED YET"
 
     xr_dataset = xr_dataset.rename(
         {"line": "owiAzSize", "sample": "owiRaSize"})
 
     xr_dataset = xr_dataset.drop_vars(
-        ['sigma0_ocean', 'sigma0', 'sigma0_ocean_raw', 'sigma0_raw', 'ancillary_wind', 'nesz', 'spatial_ref'])
-    if 'sigma0_raw__corrected' in xr_dataset:
+        [
+            "sigma0_ocean",
+            "sigma0",
+            "sigma0_ocean_raw",
+            "sigma0_raw",
+            "ancillary_wind",
+            "nesz",
+            "spatial_ref",
+        ]
+    )
+    if "sigma0_raw__corrected" in xr_dataset:
         xr_dataset = xr_dataset.drop_vars(["sigma0_raw__corrected"])
-    xr_dataset = xr_dataset.drop_dims(['pol'])
+    xr_dataset = xr_dataset.drop_dims(["pol"])
 
     table_fillValue = {
         "owiWindQuality": -1,
@@ -509,17 +645,24 @@ def makeL2asOwi(xr_dataset, config):
     for var in list(set(xr_dataset.coords.keys()) | set(xr_dataset.keys())):
         encoding[var] = {}
         try:
-            encoding[var].update({'_FillValue': table_fillValue[var]})
+            encoding[var].update({"_FillValue": table_fillValue[var]})
         except:
-            if (var in ["owiWindSpeed_co", "owiWindSpeed_cross", "owiWindSpeed"]):
-                encoding[var].update({'_FillValue': -9999.0})
+            if var in ["owiWindSpeed_co", "owiWindSpeed_cross", "owiWindSpeed"]:
+                encoding[var].update({"_FillValue": -9999.0})
             else:
-                encoding[var].update({'_FillValue': None})
+                encoding[var].update({"_FillValue": None})
 
     return xr_dataset, encoding
 
 
-def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeatures=False, resolution='1000m'):
+def preprocess(
+    filename,
+    outdir,
+    config_path,
+    overwrite=False,
+    add_gradientsfeatures=False,
+    resolution="1000m",
+):
     """
     Main function to generate L2 product.
 
@@ -546,11 +689,8 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
         filename)
 
     if os.path.exists(config_path):
-        with open(config_path, 'r') as file:
-            config_base = yaml.load(
-                file,
-                Loader=yaml.FullLoader
-            )
+        with open(config_path, "r") as file:
+            config_base = yaml.load(file, Loader=yaml.FullLoader)
         try:
             # check if sensor is in the config
             config = config_base[sensor]
@@ -558,15 +698,20 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
             raise KeyError("sensor %s not in this config" % sensor)
     else:
         raise FileNotFoundError(
-            'config_path do not exists, got %s ' % config_path)
+            "config_path do not exists, got %s " % config_path)
 
     recalibration = config["recalibration"]
     meta = fct_meta(filename)
 
     # si une des deux n'est pas VV VH HH HV on ne fait rien
-    if not all([pol in ["VV", "VH", "HH", "HV"] for pol in meta.pols.split(' ')]):
+    if not all([pol in ["VV", "VH", "HH", "HV"] for pol in meta.pols.split(" ")]):
         raise ValueError(f"Polarisation non gérée : meta.pols =  {meta.pols}")
 
+    overwrite_cfg = config_base.get("overwrite", None)
+    # If overwrite is specified in config, it will overwrite the value given as argument (which defaults to False)
+    if overwrite_cfg is not None:
+        overwrite = overwrite_cfg
+
     no_subdir_cfg = config_base.get("no_subdir", False)
     config["no_subdir"] = no_subdir_cfg
 
@@ -575,34 +720,53 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
     else:
         winddir_convention = "meteorological"
         logging.warning(
-            f'Using meteorological convention because "winddir_convention" was not found in config.')
+            f'Using meteorological convention because "winddir_convention" was not found in config.'
+        )
     config["winddir_convention"] = winddir_convention
 
     if "add_gradientsfeatures" in config_base:
         add_gradientsfeatures = config_base["add_gradientsfeatures"]
     else:
         add_gradientsfeatures = False
-        logging.warning(
-            f'Not computing gradients by default')
+        logging.warning(f"Not computing gradients by default")
     config["add_gradientsfeatures"] = add_gradientsfeatures
 
     if "add_nrcs_model" in config_base:
         add_nrcs_model = config_base["add_nrcs_model"]
         add_nrcs_model = False
         logging.warning(
-            f'Force this variable to be false, before fixing the issue'
-        )
+            f"Force add_nrcs_model to be false, before fixing an issue")
     else:
         add_nrcs_model = False
-        logging.warning(
-            f'Not computing nrcs from model by default')
+        logging.warning(f"Not computing nrcs from model by default")
     config["add_nrcs_model"] = add_nrcs_model
 
     # creating a dictionnary of parameters
     config["l2_params"] = {}
 
-    out_file = getOutputName2(filename, outdir, sensor,
-                              meta, subdir=not no_subdir_cfg)
+    meta_start_date = (
+        meta.start_date.split(".")[0]
+        .replace("-", "")
+        .replace(":", "")
+        .replace(" ", "t")
+        .replace("Z", "")
+    )
+    meta_stop_date = (
+        meta.stop_date.split(".")[0]
+        .replace("-", "")
+        .replace(":", "")
+        .replace(" ", "t")
+        .replace("Z", "")
+    )
+
+    out_file = getOutputName(
+        filename,
+        outdir,
+        sensor,
+        meta_start_date,
+        meta_stop_date,
+        subdir=not no_subdir_cfg,
+    )
 
     if os.path.exists(out_file) and overwrite is False:
         raise FileExistsError("outfile %s already exists" % out_file)
@@ -611,37 +775,48 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
     map_model = getAncillary(meta, ancillary_name)
     if map_model is None:
         raise Exception(
-            f"the weather model is not set `map_model` is None -> you probably don't have access to {ancillary_name} archive")
+            f"the weather model is not set `map_model` is None -> you probably don't have access to {ancillary_name} archive"
+        )
 
     try:
-        if ((recalibration) & ("SENTINEL" in sensor_longname)):
+        if (recalibration) & ("SENTINEL" in sensor_longname):
             logging.info(
-                f'recalibration is {recalibration} : Kersten formula is applied')
+                f"recalibration is {recalibration} : Kersten formula is applied"
+            )
             xsar_dataset = fct_dataset(
-                meta, resolution=resolution, recalibration=recalibration)
-            xr_dataset = xsar_dataset.datatree['measurement'].to_dataset()
-            xr_dataset = xr_dataset.merge(xsar_dataset.datatree["recalibration"].to_dataset()[
-                                          ['swath_number', 'swath_number_flag', 'sigma0_raw__corrected']])
+                meta, resolution=resolution, recalibration=recalibration
+            )
+            xr_dataset = xsar_dataset.datatree["measurement"].to_dataset()
+            xr_dataset = xr_dataset.merge(
+                xsar_dataset.datatree["recalibration"].to_dataset()[
+                    ["swath_number", "swath_number_flag", "sigma0_raw__corrected"]
+                ]
+            )
 
         else:
             logging.info(
-                f'recalibration is {recalibration} : Kersten formula is not applied')
-            if ("SENTINEL" in sensor_longname):
+                f"recalibration is {recalibration} : Kersten formula is not applied"
+            )
+            if "SENTINEL" in sensor_longname:
                 xsar_dataset = fct_dataset(
-                    meta, resolution=resolution, recalibration=recalibration)
-                xr_dataset = xsar_dataset.datatree['measurement'].to_dataset()
-                xr_dataset = xr_dataset.merge(xsar_dataset.datatree["recalibration"].to_dataset()[
-                                              ['swath_number', 'swath_number_flag']])
+                    meta, resolution=resolution, recalibration=recalibration
+                )
+                xr_dataset = xsar_dataset.datatree["measurement"].to_dataset()
+                xr_dataset = xr_dataset.merge(
+                    xsar_dataset.datatree["recalibration"].to_dataset()[
+                        ["swath_number", "swath_number_flag"]
+                    ]
+                )
 
             else:
                 xsar_dataset = fct_dataset(meta, resolution=resolution)
-                xr_dataset = xsar_dataset.datatree['measurement'].to_dataset()
+                xr_dataset = xsar_dataset.datatree["measurement"].to_dataset()
 
         xr_dataset = xr_dataset.rename(map_model)
         xr_dataset.attrs = xsar_dataset.dataset.attrs
 
     except Exception as e:
-        logging.info('%s', traceback.format_exc())
+        logging.info("%s", traceback.format_exc())
         logging.error(e)
         sys.exit(-1)
 
@@ -659,22 +834,24 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
     else:
         dual_pol = False
 
-    if 'VV' in xr_dataset.pol.values:
-        copol = 'VV'
-        crosspol = 'VH'
-        copol_gmf = 'VV'
-        crosspol_gmf = 'VH'
+    if "VV" in xr_dataset.pol.values:
+        copol = "VV"
+        crosspol = "VH"
+        copol_gmf = "VV"
+        crosspol_gmf = "VH"
     else:
-        logging.warning('for now this processor does not support entirely HH+HV acquisitions\n '
-                        'it wont crash but it will use HH+VH GMF for wind inversion -> wrong hypothesis\n '
-                        '!! dual WIND SPEED IS NOT USABLE !! But co WIND SPEED IS USABLE !!')
-        copol = 'HH'
-        crosspol = 'HV'
-        copol_gmf = 'HH'
-        crosspol_gmf = 'VH'
+        logging.warning(
+            "for now this processor does not support entirely HH+HV acquisitions\n "
+            "it wont crash but it will use HH+VH GMF for wind inversion -> wrong hypothesis\n "
+            "!! dual WIND SPEED IS NOT USABLE !! But co WIND SPEED IS USABLE !!"
+        )
+        copol = "HH"
+        crosspol = "HV"
+        copol_gmf = "HH"
+        crosspol_gmf = "VH"
 
-    model_co = config["GMF_"+copol_gmf+"_NAME"]
-    model_cross = config["GMF_"+crosspol_gmf+"_NAME"]
+    model_co = config["GMF_" + copol_gmf + "_NAME"]
+    model_cross = config["GMF_" + crosspol_gmf + "_NAME"]
 
     # register paramaters in config
     config["l2_params"]["dual_pol"] = dual_pol
@@ -693,16 +870,37 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
     if len(nc_luts) > 0:
         windspeed.register_nc_luts(getConf()["nc_luts_path"])
 
-    if (model_co == "gmf_cmod7"):
+    if model_co == "gmf_cmod7":
         windspeed.register_cmod7(getConf()["lut_cmod7_path"])
     #  Step 2 - clean and prepare dataset
 
     # variables to not keep in the L2
-    black_list = ['digital_number', 'gamma0_raw', 'negz',
-                  'azimuth_time', 'slant_range_time', 'velocity', 'range_ground_spacing',
-                  'gamma0', 'time', 'nd_co', 'nd_cr', 'gamma0_lut', 'sigma0_lut', "noise_lut_range", "lineSpacing",
-                  "sampleSpacing", "noise_lut", "noise_lut_azi",
-                  'nebz', 'beta0_raw', 'lines_flipped', 'samples_flipped', "altitude", "beta0"]
+    black_list = [
+        "digital_number",
+        "gamma0_raw",
+        "negz",
+        "azimuth_time",
+        "slant_range_time",
+        "velocity",
+        "range_ground_spacing",
+        "gamma0",
+        "time",
+        "nd_co",
+        "nd_cr",
+        "gamma0_lut",
+        "sigma0_lut",
+        "noise_lut_range",
+        "lineSpacing",
+        "sampleSpacing",
+        "noise_lut",
+        "noise_lut_azi",
+        "nebz",
+        "beta0_raw",
+        "lines_flipped",
+        "samples_flipped",
+        "altitude",
+        "beta0",
+    ]
     variables = list(set(xr_dataset) - set(black_list))
     xr_dataset = xr_dataset[variables]
 
@@ -729,122 +927,191 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
     # TOREMOVE
     if "offboresight" in xr_dataset:
         xr_dataset.offboresight.attrs["units"] = "degrees"
-        xr_dataset.offboresight.attrs["long_name"] = "Offboresight angle at wind cell center"
+        xr_dataset.offboresight.attrs["long_name"] = (
+            "Offboresight angle at wind cell center"
+        )
         xr_dataset.elevation.attrs["standard_name"] = "offboresight"
 
     # masks (no ice / no_valid)
-    xr_dataset.land_mask.values = binary_dilation(xr_dataset['land_mask'].values.astype('uint8'),
-                                                  structure=np.ones((3, 3), np.uint8), iterations=3)
-    xr_dataset.land_mask.attrs['long_name'] = 'Mask of data'
-    xr_dataset.land_mask.attrs['valid_range'] = np.array([0, 1])
-    xr_dataset.land_mask.attrs['flag_values'] = np.array([0, 1])
-    xr_dataset.land_mask.attrs['flag_meanings'] = 'valid no_valid'
+    xr_dataset.land_mask.values = binary_dilation(
+        xr_dataset["land_mask"].values.astype("uint8"),
+        structure=np.ones((3, 3), np.uint8),
+        iterations=3,
+    )
+    xr_dataset.land_mask.attrs["long_name"] = "Mask of data"
+    xr_dataset.land_mask.attrs["valid_range"] = np.array([0, 1])
+    xr_dataset.land_mask.attrs["flag_values"] = np.array([0, 1])
+    xr_dataset.land_mask.attrs["flag_meanings"] = "valid no_valid"
 
     logging.debug("mask is a copy of land_mask")
 
-    xr_dataset['mask'] = xr.DataArray(xr_dataset.land_mask)
+    xr_dataset["mask"] = xr.DataArray(xr_dataset.land_mask)
     xr_dataset.mask.attrs = {}
-    xr_dataset.mask.attrs['long_name'] = 'Mask of data'
-    xr_dataset.mask.attrs['valid_range'] = np.array([0, 3])
-    xr_dataset.mask.attrs['flag_values'] = np.array([0, 1, 2, 3])
-    xr_dataset.mask.attrs['flag_meanings'] = 'valid land ice no_valid'
+    xr_dataset.mask.attrs["long_name"] = "Mask of data"
+    xr_dataset.mask.attrs["valid_range"] = np.array([0, 3])
+    xr_dataset.mask.attrs["flag_values"] = np.array([0, 1, 2, 3])
+    xr_dataset.mask.attrs["flag_meanings"] = "valid land ice no_valid"
 
     # ancillary
-    xr_dataset['ancillary_wind_direction'] = (
-        90. - np.rad2deg(np.arctan2(xr_dataset.model_V10, xr_dataset.model_U10)) + 180) % 360
-
-    xr_dataset['ancillary_wind_direction'] = xr.where(xr_dataset['mask'], np.nan,
-                                                      xr_dataset['ancillary_wind_direction']).transpose(
-        *xr_dataset['ancillary_wind_direction'].dims)
-    xr_dataset['ancillary_wind_direction'].attrs = {}
-    xr_dataset['ancillary_wind_direction'].attrs['units'] = 'degrees_north'
-    xr_dataset['ancillary_wind_direction'].attrs[
-        'long_name'] = f'{ancillary_name} wind direction in meteorological convention (clockwise, from), ex: 0°=from north, 90°=from east'
-    xr_dataset['ancillary_wind_direction'].attrs['standart_name'] = 'wind_direction'
-
-    xr_dataset['ancillary_wind_speed'] = np.sqrt(
-        xr_dataset['model_U10']**2+xr_dataset['model_V10']**2)
-    xr_dataset['ancillary_wind_speed'] = xr.where(xr_dataset['mask'], np.nan,
-                                                  xr_dataset['ancillary_wind_speed']).transpose(
-        *xr_dataset['ancillary_wind_speed'].dims)
-    xr_dataset['ancillary_wind_speed'].attrs = {}
-    xr_dataset['ancillary_wind_speed'].attrs['units'] = 'm s^-1'
-    xr_dataset['ancillary_wind_speed'].attrs[
-        'long_name'] = f'{ancillary_name} wind speed'
-    xr_dataset['ancillary_wind_speed'].attrs['standart_name'] = 'wind_speed'
-
-    xr_dataset['ancillary_wind'] = xr.where(xr_dataset['mask'], np.nan,
-                                            (xr_dataset.ancillary_wind_speed * np.exp(1j * xsarsea.dir_meteo_to_sample(xr_dataset.ancillary_wind_direction, xr_dataset.ground_heading)))).transpose(
-        *xr_dataset['ancillary_wind_speed'].dims)
-
-    xr_dataset.attrs['ancillary_source'] = xr_dataset['model_U10'].attrs['history'].split('decoded: ')[
-        1].strip()
-    xr_dataset = xr_dataset.drop_vars(['model_U10', 'model_V10'])
+    xr_dataset["ancillary_wind_direction"] = (
+        90.0 - np.rad2deg(np.arctan2(xr_dataset.model_V10,
+                          xr_dataset.model_U10)) + 180
+    ) % 360
+
+    xr_dataset["ancillary_wind_direction"] = xr.where(
+        xr_dataset["mask"], np.nan, xr_dataset["ancillary_wind_direction"]
+    ).transpose(*xr_dataset["ancillary_wind_direction"].dims)
+    xr_dataset["ancillary_wind_direction"].attrs = {}
+    xr_dataset["ancillary_wind_direction"].attrs["units"] = "degrees_north"
+    xr_dataset["ancillary_wind_direction"].attrs[
+        "long_name"
+    ] = f"{ancillary_name} wind direction in meteorological convention (clockwise, from), ex: 0°=from north, 90°=from east"
+    xr_dataset["ancillary_wind_direction"].attrs["standart_name"] = "wind_direction"
+
+    xr_dataset["ancillary_wind_speed"] = np.sqrt(
+        xr_dataset["model_U10"] ** 2 + xr_dataset["model_V10"] ** 2
+    )
+    xr_dataset["ancillary_wind_speed"] = xr.where(
+        xr_dataset["mask"], np.nan, xr_dataset["ancillary_wind_speed"]
+    ).transpose(*xr_dataset["ancillary_wind_speed"].dims)
+    xr_dataset["ancillary_wind_speed"].attrs = {}
+    xr_dataset["ancillary_wind_speed"].attrs["units"] = "m s^-1"
+    xr_dataset["ancillary_wind_speed"].attrs[
+        "long_name"
+    ] = f"{ancillary_name} wind speed"
+    xr_dataset["ancillary_wind_speed"].attrs["standart_name"] = "wind_speed"
+
+    xr_dataset["ancillary_wind"] = xr.where(
+        xr_dataset["mask"],
+        np.nan,
+        (
+            xr_dataset.ancillary_wind_speed
+            * np.exp(
+                1j
+                * xsarsea.dir_meteo_to_sample(
+                    xr_dataset.ancillary_wind_direction, xr_dataset.ground_heading
+                )
+            )
+        ),
+    ).transpose(*xr_dataset["ancillary_wind_speed"].dims)
+
+    xr_dataset.attrs["ancillary_source"] = (
+        xr_dataset["model_U10"].attrs["history"].split("decoded: ")[1].strip()
+    )
+    xr_dataset = xr_dataset.drop_vars(["model_U10", "model_V10"])
 
     # nrcs processing
-    xr_dataset['sigma0_ocean'] = xr.where(xr_dataset['mask'], np.nan,
-                                          xr_dataset['sigma0']).transpose(*xr_dataset['sigma0'].dims)
-    xr_dataset['sigma0_ocean'].attrs = xr_dataset['sigma0'].attrs
+    xr_dataset["sigma0_ocean"] = xr.where(
+        xr_dataset["mask"], np.nan, xr_dataset["sigma0"]
+    ).transpose(*xr_dataset["sigma0"].dims)
+    xr_dataset["sigma0_ocean"].attrs = xr_dataset["sigma0"].attrs
     #  we forced it to 1e-15
-    xr_dataset['sigma0_ocean'].attrs['comment'] = "clipped, no values <=0 ; 1e-15 instread"
+    xr_dataset["sigma0_ocean"].attrs[
+        "comment"
+    ] = "clipped, no values <=0 ; 1e-15 instread"
 
     # rajout d'un mask pour les valeurs <=0:
-    xr_dataset['sigma0_mask'] = xr.where(
-        xr_dataset['sigma0_ocean'] <= 0, 1, 0).transpose(*xr_dataset['sigma0'].dims)
-    xr_dataset.sigma0_mask.attrs['valid_range'] = np.array([0, 1])
-    xr_dataset.sigma0_mask.attrs['flag_values'] = np.array([0, 1])
-    xr_dataset.sigma0_mask.attrs['flag_meanings'] = 'valid no_valid'
-    xr_dataset['sigma0_ocean'] = xr.where(
-        xr_dataset['sigma0_ocean'] <= 0, 1e-15, xr_dataset['sigma0_ocean'])
+    xr_dataset["sigma0_mask"] = xr.where(
+        xr_dataset["sigma0_ocean"] <= 0, 1, 0
+    ).transpose(*xr_dataset["sigma0"].dims)
+    xr_dataset.sigma0_mask.attrs["valid_range"] = np.array([0, 1])
+    xr_dataset.sigma0_mask.attrs["flag_values"] = np.array([0, 1])
+    xr_dataset.sigma0_mask.attrs["flag_meanings"] = "valid no_valid"
+    xr_dataset["sigma0_ocean"] = xr.where(
+        xr_dataset["sigma0_ocean"] <= 0, 1e-15, xr_dataset["sigma0_ocean"]
+    )
 
-    xr_dataset['sigma0_ocean_raw'] = xr.where(xr_dataset['mask'], np.nan,
-                                              xr_dataset['sigma0_raw']).transpose(*xr_dataset['sigma0_raw'].dims)
+    xr_dataset["sigma0_ocean_raw"] = xr.where(
+        xr_dataset["mask"], np.nan, xr_dataset["sigma0_raw"]
+    ).transpose(*xr_dataset["sigma0_raw"].dims)
 
-    xr_dataset['sigma0_ocean_raw'].attrs = xr_dataset['sigma0_raw'].attrs
+    xr_dataset["sigma0_ocean_raw"].attrs = xr_dataset["sigma0_raw"].attrs
 
-    xr_dataset['sigma0_detrend'] = xsarsea.sigma0_detrend(
-        xr_dataset.sigma0.sel(pol=copol), xr_dataset.incidence, model=model_co)
+    xr_dataset["sigma0_detrend"] = xsarsea.sigma0_detrend(
+        xr_dataset.sigma0.sel(pol=copol), xr_dataset.incidence, model=model_co
+    )
 
     # processing
     if dual_pol:
 
         xr_dataset['sigma0_detrend_cross'] = xsarsea.sigma0_detrend(
             xr_dataset.sigma0.sel(pol=crosspol), xr_dataset.incidence, model=model_cross)
+
+        xr_dataset = xr_dataset.assign(nesz_cross_flattened=(
+            ['line', 'sample'], windspeed.nesz_flattening(xr_dataset.nesz.sel(pol=crosspol), xr_dataset.incidence).data))
+
+        xr_dataset['nesz_cross_flattened'].attrs[
+            "comment"] = 'nesz has been flattened using windspeed.nesz_flattening'
+
         if config["apply_flattening"]:
-            xr_dataset = xr_dataset.assign(nesz_cross_flattened=(
-                ['line', 'sample'], windspeed.nesz_flattening(xr_dataset.nesz.sel(pol=crosspol), xr_dataset.incidence).data))
-            xr_dataset['nesz_cross_flattened'].attrs[
-                "comment"] = 'nesz has been flattened using windspeed.nesz_flattening'
             # dsig
-            xr_dataset["dsig_cross"] = windspeed.get_dsig(config["dsig_"+crosspol_gmf+"_NAME"], xr_dataset.incidence,
-                                                          xr_dataset['sigma0_ocean'].sel(pol=crosspol), xr_dataset.nesz_cross_flattened)
+            xr_dataset["dsig_cross"] = windspeed.get_dsig(
+                config["dsig_" + crosspol_gmf + "_NAME"],
+                xr_dataset.incidence,
+                xr_dataset["sigma0_ocean"].sel(pol=crosspol),
+                xr_dataset.nesz_cross_flattened,
+            )
+
+            xr_dataset.dsig_cross.attrs["formula_used"] = config[
+                "dsig_" + crosspol_gmf + "_NAME"
+            ]
+
         else:
             # dsig
-            xr_dataset["dsig_cross"] = windspeed.get_dsig(config["dsig_"+crosspol_gmf+"_NAME"], xr_dataset.incidence,
-                                                          xr_dataset['sigma0_ocean'].sel(pol=crosspol), xr_dataset.nesz.sel(pol=crosspol))
-
-        xr_dataset.dsig_cross.attrs['comment'] = 'variable used to ponderate copol and crosspol'
-        xr_dataset.dsig_cross.attrs['formula_used'] = config["dsig_" +
-                                                             crosspol_gmf+"_NAME"]
-        xr_dataset.dsig_cross.attrs['apply_flattening'] = str(
-            config["apply_flattening"])
-
-    if ((recalibration) & ("SENTINEL" in sensor_longname)):
-        xr_dataset.attrs["path_aux_pp1_new"] = os.path.basename(os.path.dirname(
-            os.path.dirname(xsar_dataset.datatree['recalibration'].attrs['path_aux_pp1_new'])))
-        xr_dataset.attrs["path_aux_cal_new"] = os.path.basename(os.path.dirname(
-            os.path.dirname(xsar_dataset.datatree['recalibration'].attrs['path_aux_cal_new'])))
-
-        xr_dataset.attrs["path_aux_pp1_old"] = os.path.basename(os.path.dirname(
-            os.path.dirname(xsar_dataset.datatree['recalibration'].attrs['path_aux_pp1_old'])))
-        xr_dataset.attrs["path_aux_cal_old"] = os.path.basename(os.path.dirname(
-            os.path.dirname(xsar_dataset.datatree['recalibration'].attrs['path_aux_cal_old'])))
+            xr_dataset["dsig_cross"] = windspeed.get_dsig(
+                config["dsig_" + crosspol_gmf + "_NAME"],
+                xr_dataset.incidence,
+                xr_dataset["sigma0_ocean"].sel(pol=crosspol),
+                xr_dataset.nesz.sel(pol=crosspol),
+            )
+
+        xr_dataset.dsig_cross.attrs["comment"] = (
+            "variable used to ponderate copol and crosspol"
+        )
+
+        xr_dataset.dsig_cross.attrs["apply_flattening"] = str(
+            config["apply_flattening"]
+        )
+
+    if (recalibration) & ("SENTINEL" in sensor_longname):
+        xr_dataset.attrs["path_aux_pp1_new"] = os.path.basename(
+            os.path.dirname(
+                os.path.dirname(
+                    xsar_dataset.datatree["recalibration"].attrs["path_aux_pp1_new"]
+                )
+            )
+        )
+        xr_dataset.attrs["path_aux_cal_new"] = os.path.basename(
+            os.path.dirname(
+                os.path.dirname(
+                    xsar_dataset.datatree["recalibration"].attrs["path_aux_cal_new"]
+                )
+            )
+        )
+
+        xr_dataset.attrs["path_aux_pp1_old"] = os.path.basename(
+            os.path.dirname(
+                os.path.dirname(
+                    xsar_dataset.datatree["recalibration"].attrs["path_aux_pp1_old"]
+                )
+            )
+        )
+        xr_dataset.attrs["path_aux_cal_old"] = os.path.basename(
+            os.path.dirname(
+                os.path.dirname(
+                    xsar_dataset.datatree["recalibration"].attrs["path_aux_cal_old"]
+                )
+            )
+        )
 
     if add_nrcs_model:
         # add timing
         phi = np.abs(
-            np.rad2deg(xsarsea.dir_meteo_to_sample(
-                xr_dataset["ancillary_wind_direction"], xr_dataset["ground_heading"]))
+            np.rad2deg(
+                xsarsea.dir_meteo_to_sample(
+                    xr_dataset["ancillary_wind_direction"], xr_dataset["ground_heading"]
+                )
+            )
         )
 
         varnames = ["ancillary_nrcs"]
@@ -866,9 +1133,7 @@ def preprocess(filename, outdir, config_path, overwrite=False, add_gradientsfeat
                             incidence=incidence, wspd=wspd, phi=phi, method="nearest"
                         )
                     else:
-                        return lut.sel(
-                            incidence=incidence, wspd=wspd, method="nearest"
-                        )
+                        return lut.sel(incidence=incidence, wspd=wspd, method="nearest")
 
                 xr_dataset[varnames[idx]] = xr.apply_ufunc(
                     lut_selection,
@@ -920,38 +1185,46 @@ def process_gradients(xr_dataset, config):
     dual_pol = config["l2_params"]["dual_pol"]
 
     # Load the 100m dataset
-    xsar_dataset_100 = fct_dataset(
-        meta, resolution='100m')
+    xsar_dataset_100 = fct_dataset(meta, resolution="100m")
 
-    xr_dataset_100 = xsar_dataset_100.datatree['measurement'].to_dataset()
+    xr_dataset_100 = xsar_dataset_100.datatree["measurement"].to_dataset()
     xr_dataset_100 = xr_dataset_100.rename(map_model)
     # load dataset
     xr_dataset_100 = xr_dataset_100.load()
 
     # adding sigma0 detrend
-    xr_dataset_100['sigma0_detrend'] = xsarsea.sigma0_detrend(
-        xr_dataset_100.sigma0.sel(pol=copol), xr_dataset_100.incidence, model=model_co)
+    xr_dataset_100["sigma0_detrend"] = xsarsea.sigma0_detrend(
+        xr_dataset_100.sigma0.sel(pol=copol), xr_dataset_100.incidence, model=model_co
+    )
 
     if dual_pol:
-        xr_dataset_100['sigma0_detrend_cross'] = xsarsea.sigma0_detrend(
-            xr_dataset_100.sigma0.sel(pol=crosspol), xr_dataset_100.incidence, model=model_cross)
+        xr_dataset_100["sigma0_detrend_cross"] = xsarsea.sigma0_detrend(
+            xr_dataset_100.sigma0.sel(pol=crosspol),
+            xr_dataset_100.incidence,
+            model=model_cross,
+        )
 
         sigma0_detrend_combined = xr.concat(
-            [xr_dataset_100['sigma0_detrend'],
-                xr_dataset_100['sigma0_detrend_cross']],
-            dim='pol'
+            [xr_dataset_100["sigma0_detrend"],
+                xr_dataset_100["sigma0_detrend_cross"]],
+            dim="pol",
         )
-        sigma0_detrend_combined['pol'] = [copol, crosspol]
+        sigma0_detrend_combined["pol"] = [copol, crosspol]
 
-        xr_dataset_100['sigma0_detrend'] = sigma0_detrend_combined
+        xr_dataset_100["sigma0_detrend"] = sigma0_detrend_combined
 
-    xr_dataset_100.land_mask.values = binary_dilation(xr_dataset_100['land_mask'].values.astype('uint8'),
-                                                      structure=np.ones((3, 3), np.uint8), iterations=3)
-    xr_dataset_100['sigma0_detrend'] = xr.where(
-        xr_dataset_100['land_mask'], np.nan, xr_dataset_100['sigma0']).transpose(*xr_dataset_100['sigma0'].dims)
+    xr_dataset_100.land_mask.values = binary_dilation(
+        xr_dataset_100["land_mask"].values.astype("uint8"),
+        structure=np.ones((3, 3), np.uint8),
+        iterations=3,
+    )
+    xr_dataset_100["sigma0_detrend"] = xr.where(
+        xr_dataset_100["land_mask"], np.nan, xr_dataset_100["sigma0"]
+    ).transpose(*xr_dataset_100["sigma0"].dims)
 
-    xr_dataset_100['ancillary_wind'] = (
-        xr_dataset_100.model_U10 + 1j * xr_dataset_100.model_V10) * np.exp(1j * np.deg2rad(xr_dataset_100.ground_heading))
+    xr_dataset_100["ancillary_wind"] = (
+        xr_dataset_100.model_U10 + 1j * xr_dataset_100.model_V10
+    ) * np.exp(1j * np.deg2rad(xr_dataset_100.ground_heading))
 
     downscales_factors = [1, 2, 4, 8]
     # 4 and 8 must be in downscales_factors
@@ -962,7 +1235,7 @@ def process_gradients(xr_dataset, config):
         xr_dataset_100=xr_dataset_100,
         windows_sizes=[1600, 3200],
         downscales_factors=downscales_factors,
-        window_step=1
+        window_step=1,
     )
 
     # Compute heterogeneity mask and variables
@@ -971,24 +1244,29 @@ def process_gradients(xr_dataset, config):
 
     # Add streaks dataset
     streaks_indiv = gradientFeatures.streaks_individual()
-    if 'longitude' in streaks_indiv:
-        xr_dataset_streaks = xr.Dataset({
-            'longitude': streaks_indiv.longitude,
-            'latitude': streaks_indiv.latitude,
-            'dir_smooth': streaks_indiv.angle,
-            'dir_mean_smooth': gradientFeatures.streaks_mean_smooth().angle,
-            'dir_smooth_mean': gradientFeatures.streaks_smooth_mean().angle,
-        })
+    if "longitude" in streaks_indiv:
+        xr_dataset_streaks = xr.Dataset(
+            {
+                "longitude": streaks_indiv.longitude,
+                "latitude": streaks_indiv.latitude,
+                "dir_smooth": streaks_indiv.angle,
+                "dir_mean_smooth": gradientFeatures.streaks_mean_smooth().angle,
+                "dir_smooth_mean": gradientFeatures.streaks_smooth_mean().angle,
+            }
+        )
     else:
         logger.warn(
-            "'longitude' not found in streaks_indiv : there is probably an error")
+            "'longitude' not found in streaks_indiv : there is probably an error"
+        )
         xr_dataset_streaks = None
 
     return xr_dataset, xr_dataset_streaks
 
 
 @timing(logger=logger.info)
-def makeL2(filename, outdir, config_path, overwrite=False, generateCSV=True, resolution='1000m'):
+def makeL2(
+    filename, outdir, config_path, overwrite=False, generateCSV=True, resolution="1000m"
+):
     """
     Main function to generate L2 product.
 
@@ -1016,11 +1294,11 @@ def makeL2(filename, outdir, config_path, overwrite=False, generateCSV=True, res
     """
 
     xr_dataset, out_file, config = preprocess(
-        filename, outdir, config_path, overwrite, resolution)
+        filename, outdir, config_path, overwrite, resolution
+    )
 
     if config["add_gradientsfeatures"]:
-        xr_dataset, xr_dataset_streaks = process_gradients(
-            xr_dataset, config)
+        xr_dataset, xr_dataset_streaks = process_gradients(xr_dataset, config)
     else:
         xr_dataset_streaks = None
 
@@ -1035,8 +1313,8 @@ def makeL2(filename, outdir, config_path, overwrite=False, generateCSV=True, res
     sensor_longname = config["sensor_longname"]
 
     if dual_pol:
-        sigma0_ocean_cross = xr_dataset['sigma0_ocean'].sel(pol=crosspol)
-        dsig_cross = xr_dataset['dsig_cross']
+        sigma0_ocean_cross = xr_dataset["sigma0_ocean"].sel(pol=crosspol)
+        dsig_cross = xr_dataset["dsig_cross"]
     else:
         sigma0_ocean_cross = None
         dsig_cross = 0.1  # default value set in xsarsea
@@ -1054,97 +1332,119 @@ def makeL2(filename, outdir, config_path, overwrite=False, generateCSV=True, res
     logging.info("Checking incidence range within LUTS incidence range")
     #  warning if incidence is out of lut incidence range
     inc_check_co, inc_check_cross = check_incidence_range(
-        xr_dataset['incidence'], [model_co, model_cross], **kwargs)
-
-    wind_co, wind_dual, windspeed_cr = inverse(dual_pol,
-                                               inc=xr_dataset['incidence'],
-                                               sigma0=xr_dataset['sigma0_ocean'].sel(
-                                                   pol=copol),
-                                               sigma0_dual=sigma0_ocean_cross,
-                                               ancillary_wind=xr_dataset['ancillary_wind'],
-                                               dsig_cr=dsig_cross,
-                                               model_co=model_co,
-                                               model_cross=model_cross,
-                                               ** kwargs)
+        xr_dataset["incidence"], [model_co, model_cross], **kwargs
+    )
+
+    wind_co, wind_dual, windspeed_cr = inverse(
+        dual_pol,
+        inc=xr_dataset["incidence"],
+        sigma0=xr_dataset["sigma0_ocean"].sel(pol=copol),
+        sigma0_dual=sigma0_ocean_cross,
+        ancillary_wind=xr_dataset["ancillary_wind"],
+        dsig_cr=dsig_cross,
+        model_co=model_co,
+        model_cross=model_cross,
+        **kwargs,
+    )
     # windspeed_co
-    xr_dataset['windspeed_co'] = np.abs(wind_co)
+    xr_dataset["windspeed_co"] = np.abs(wind_co)
     xr_dataset["windspeed_co"].attrs["units"] = "m.s⁻1"
-    xr_dataset["windspeed_co"].attrs["long_name"] = "Wind speed inverted from model %s (%s)" % (
-        model_co, copol)
+    xr_dataset["windspeed_co"].attrs["long_name"] = (
+        "Wind speed inverted from model %s (%s)" % (model_co, copol)
+    )
     xr_dataset["windspeed_co"].attrs["standart_name"] = "wind_speed"
     xr_dataset["windspeed_co"].attrs["model"] = wind_co.attrs["model"]
-    del xr_dataset["windspeed_co"].attrs['comment']
+    del xr_dataset["windspeed_co"].attrs["comment"]
 
     # winddir_co
-    xr_dataset['winddir_co'] = transform_winddir(
-        wind_co, xr_dataset.ground_heading, winddir_convention=config["winddir_convention"])
-    xr_dataset['winddir_co'].attrs["model"] = "%s (%s)" % (model_co, copol)
+    xr_dataset["winddir_co"] = transform_winddir(
+        wind_co,
+        xr_dataset.ground_heading,
+        winddir_convention=config["winddir_convention"],
+    )
+    xr_dataset["winddir_co"].attrs["model"] = "%s (%s)" % (model_co, copol)
 
     # windspeed_dual / windspeed_cr / /winddir_dual / winddir_cr
     if dual_pol and wind_dual is not None:
-        xr_dataset['windspeed_dual'] = np.abs(wind_dual)
+        xr_dataset["windspeed_dual"] = np.abs(wind_dual)
         xr_dataset["windspeed_dual"].attrs["units"] = "m.s⁻1"
-        xr_dataset["windspeed_dual"].attrs["long_name"] = "Wind speed inverted from model %s (%s) & %s (%s)" % (
-            model_co, copol, model_cross, crosspol)
+        xr_dataset["windspeed_dual"].attrs["long_name"] = (
+            "Wind speed inverted from model %s (%s) & %s (%s)"
+            % (model_co, copol, model_cross, crosspol)
+        )
         xr_dataset["windspeed_dual"].attrs["standart_name"] = "wind_speed"
         xr_dataset["windspeed_dual"].attrs["model"] = wind_dual.attrs["model"]
-        del xr_dataset["windspeed_dual"].attrs['comment']
+        del xr_dataset["windspeed_dual"].attrs["comment"]
 
-        xr_dataset['winddir_dual'] = transform_winddir(
-            wind_dual, xr_dataset.ground_heading, winddir_convention=config["winddir_convention"])
-        xr_dataset["winddir_dual"].attrs["model"] = "winddir_dual is a copy of copol wind direction"
+        xr_dataset["winddir_dual"] = transform_winddir(
+            wind_dual,
+            xr_dataset.ground_heading,
+            winddir_convention=config["winddir_convention"],
+        )
+        xr_dataset["winddir_dual"].attrs[
+            "model"
+        ] = "winddir_dual is a copy of copol wind direction"
 
         xr_dataset = xr_dataset.assign(
-            windspeed_cross=(['line', 'sample'], windspeed_cr.data))
+            windspeed_cross=(["line", "sample"], windspeed_cr.data)
+        )
         xr_dataset["windspeed_cross"].attrs["units"] = "m.s⁻1"
-        xr_dataset["windspeed_cross"].attrs["long_name"] = "Wind Speed inverted from model %s (%s)" % (
-            model_cross, crosspol)
+        xr_dataset["windspeed_cross"].attrs["long_name"] = (
+            "Wind Speed inverted from model %s (%s)" % (model_cross, crosspol)
+        )
         xr_dataset["windspeed_cross"].attrs["standart_name"] = "wind_speed"
         xr_dataset["windspeed_cross"].attrs["model"] = "%s" % (model_cross)
 
-        xr_dataset['winddir_cross'] = xr_dataset['winddir_dual'].copy()
-        xr_dataset['winddir_cross'].attrs = xr_dataset['winddir_dual'].attrs
-        xr_dataset["winddir_cross"].attrs["model"] = "winddir_cross is a copy of copol wind direction"
+        xr_dataset["winddir_cross"] = xr_dataset["winddir_dual"].copy()
+        xr_dataset["winddir_cross"].attrs = xr_dataset["winddir_dual"].attrs
+        xr_dataset["winddir_cross"].attrs[
+            "model"
+        ] = "winddir_cross is a copy of copol wind direction"
 
     if config["winddir_convention"] == "oceanographic":
-        attrs = xr_dataset['ancillary_wind_direction'].attrs
-        xr_dataset['ancillary_wind_direction'] = xsarsea.dir_meteo_to_oceano(
-            xr_dataset['ancillary_wind_direction'])
-        xr_dataset['ancillary_wind_direction'].attrs = attrs
-        xr_dataset['ancillary_wind_direction'].attrs[
-            "long_name"] = f"{ancillary_name} wind direction in oceanographic convention (clockwise, to), ex: 0°=to north, 90°=to east"
+        attrs = xr_dataset["ancillary_wind_direction"].attrs
+        xr_dataset["ancillary_wind_direction"] = xsarsea.dir_meteo_to_oceano(
+            xr_dataset["ancillary_wind_direction"]
+        )
+        xr_dataset["ancillary_wind_direction"].attrs = attrs
+        xr_dataset["ancillary_wind_direction"].attrs[
+            "long_name"
+        ] = f"{ancillary_name} wind direction in oceanographic convention (clockwise, to), ex: 0°=to north, 90°=to east"
 
-    xr_dataset, encoding = makeL2asOwi(
-        xr_dataset, config)
+    xr_dataset, encoding = makeL2asOwi(xr_dataset, config)
 
     xr_dataset = xr_dataset.compute()
     #  add attributes
     firstMeasurementTime = None
     lastMeasurementTime = None
     try:
-        firstMeasurementTime = datetime.datetime.strptime(xr_dataset.attrs['start_date'],
-                                                          "%Y-%m-%d %H:%M:%S.%f").strftime(
-            "%Y-%m-%dT%H:%M:%SZ")
-        lastMeasurementTime = datetime.datetime.strptime(xr_dataset.attrs['stop_date'],
-                                                         "%Y-%m-%d %H:%M:%S.%f").strftime(
-            "%Y-%m-%dT%H:%M:%SZ")
+        firstMeasurementTime = datetime.datetime.strptime(
+            xr_dataset.attrs["start_date"], "%Y-%m-%d %H:%M:%S.%f"
+        ).strftime("%Y-%m-%dT%H:%M:%SZ")
+        lastMeasurementTime = datetime.datetime.strptime(
+            xr_dataset.attrs["stop_date"], "%Y-%m-%d %H:%M:%S.%f"
+        ).strftime("%Y-%m-%dT%H:%M:%SZ")
     except:
-        firstMeasurementTime = datetime.datetime.strptime(xr_dataset.attrs['start_date'],
-                                                          "%Y-%m-%d %H:%M:%S").strftime(
-            "%Y-%m-%dT%H:%M:%SZ")
-        lastMeasurementTime = datetime.datetime.strptime(xr_dataset.attrs['stop_date'],
-                                                         "%Y-%m-%d %H:%M:%S").strftime(
-            "%Y-%m-%dT%H:%M:%SZ")
+        firstMeasurementTime = datetime.datetime.strptime(
+            xr_dataset.attrs["start_date"], "%Y-%m-%d %H:%M:%S"
+        ).strftime("%Y-%m-%dT%H:%M:%SZ")
+        lastMeasurementTime = datetime.datetime.strptime(
+            xr_dataset.attrs["stop_date"], "%Y-%m-%d %H:%M:%S"
+        ).strftime("%Y-%m-%dT%H:%M:%SZ")
 
     attrs = {
         "TITLE": "Sentinel-1 OWI Component",
         "productOwner": "IFREMER",
-        "sourceProduct": (xr_dataset.attrs["safe"] if "safe" in xr_dataset.attrs else os.path.basename(xr_dataset.attrs["product_path"])),
-        "sourceProduct_fullpath": xr_dataset.attrs.pop('name'),
+        "sourceProduct": (
+            xr_dataset.attrs["safe"]
+            if "safe" in xr_dataset.attrs
+            else os.path.basename(xr_dataset.attrs["product_path"])
+        ),
+        "sourceProduct_fullpath": xr_dataset.attrs.pop("name"),
         "missionName": sensor_longname,
-        "missionPhase":  "Operational",
-        "polarisation": xr_dataset.attrs['pols'],
-        "acquisitionStation": '',
+        "missionPhase": "Operational",
+        "polarisation": xr_dataset.attrs["pols"],
+        "acquisitionStation": "",
         "xsar_version": xsar.__version__,
         "xsarsea_version": xsarsea.__version__,
         "pythonVersion": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
@@ -1157,25 +1457,32 @@ def makeL2(filename, outdir, config_path, overwrite=False, generateCSV=True, res
         "bathySource": "/",
         "oswAlgorithmName": "grdwindinversion",
         "owiAlgorithmVersion": grdwindinversion.__version__,
-        "gmf": config['GMF_'+copol_gmf+'_NAME'] + ", " + config["GMF_"+crosspol_gmf+"_NAME"],
+        "gmf": config["GMF_" + copol_gmf + "_NAME"]
+        + ", "
+        + config["GMF_" + crosspol_gmf + "_NAME"],
         "iceSource": "/",
         "owiNoiseCorrection": "True",
-        "inversionTabGMF": config['GMF_'+copol_gmf +
-                                  '_NAME'] + ", " + config["GMF_"+crosspol_gmf+"_NAME"],
+        "inversionTabGMF": config["GMF_" + copol_gmf + "_NAME"]
+        + ", "
+        + config["GMF_" + crosspol_gmf + "_NAME"],
         "wnf_3km_average": "False",
         "owiWindSpeedSrc": "owiWindSpeed",
         "owiWindDirectionSrc": "/",
-        "ancillary_source": xr_dataset.attrs['ancillary_source'],
+        "ancillary_source": xr_dataset.attrs["ancillary_source"],
         "winddir_convention": config["winddir_convention"],
         "incidence_within_lut_copol_incidence_range": str(inc_check_co),
         "incidence_within_lut_crosspol_incidence_range": str(inc_check_cross),
-        "swath": xr_dataset.attrs['swath'],
-        "footprint": xr_dataset.attrs['footprint'],
-        "coverage": xr_dataset.attrs['coverage'],
-
+        "swath": xr_dataset.attrs["swath"],
+        "footprint": xr_dataset.attrs["footprint"],
+        "coverage": xr_dataset.attrs["coverage"],
     }
 
-    for recalib_attrs in ["path_aux_pp1_new", 'path_aux_pp1_old', "path_aux_cal_new", "path_aux_cal_old"]:
+    for recalib_attrs in [
+        "path_aux_pp1_new",
+        "path_aux_pp1_old",
+        "path_aux_cal_new",
+        "path_aux_cal_old",
+    ]:
         if recalib_attrs in xr_dataset.attrs:
             attrs[recalib_attrs] = xr_dataset.attrs[recalib_attrs]
 
@@ -1190,11 +1497,11 @@ def makeL2(filename, outdir, config_path, overwrite=False, generateCSV=True, res
         if sup_attr in xr_dataset.attrs:
             attrs[sup_attr] = xr_dataset.attrs[sup_attr]
 
-    attrs['footprint'] = str(attrs['footprint'])
+    attrs["footprint"] = str(attrs["footprint"])
 
     # add in kwargs in attrs
     for key in kwargs:
-        attrs["lut_params_"+key] = "/" if kwargs[key] is None else kwargs[key]
+        attrs["lut_params_" + key] = "/" if kwargs[key] is None else kwargs[key]
 
     xr_dataset.attrs = attrs
 
@@ -1233,7 +1540,7 @@ def makeL2(filename, outdir, config_path, overwrite=False, generateCSV=True, res
     return out_file, xr_dataset
 
 
-def transform_winddir(wind_cpx, ground_heading, winddir_convention='meteorological'):
+def transform_winddir(wind_cpx, ground_heading, winddir_convention="meteorological"):
     """
 
     Parameters
@@ -1254,7 +1561,8 @@ def transform_winddir(wind_cpx, ground_heading, winddir_convention='meteorologic
     """
     # to meteo winddir_convention
     dataArray = xsarsea.dir_sample_to_meteo(
-        np.angle(wind_cpx, deg=True), ground_heading)
+        np.angle(wind_cpx, deg=True), ground_heading
+    )
     long_name = "Wind direction in meteorological convention (clockwise, from), ex: 0°=from north, 90°=from east"
 
     if winddir_convention == "meteorological":
@@ -1267,7 +1575,8 @@ def transform_winddir(wind_cpx, ground_heading, winddir_convention='meteorologic
     else:
         #  warning
         logging.warning(
-            f"wind direction convention {winddir_convention} is not supported, using meteorological",)
+            f"wind direction convention {winddir_convention} is not supported, using meteorological",
+        )
         long_name = "Wind direction in meteorological convention (clockwise, from), ex: 0°=from north, 90°=from east"
 
     dataArray = xsarsea.dir_to_360(dataArray)