smashbox 1.0__py2.py3-none-any.whl

smashbox/stats/stats.py

@@ -0,0 +1,2022 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jul 22 10:47:46 2025
+
+@author: maxime
+"""
+
+import numpy as np
+import pandas as pd
+import warnings
+import scipy.stats as stats
+import multiprocessing
+import matplotlib.pyplot as plt
+import os
+from tqdm import tqdm
+import threading
+from smashbox.tools import tools
+from smash.fcore import _mwd_metrics as smash_metrics
+
+
+@tools.autocast_args
+def _get_mask_colum_nodata(arr, nodata=-99.0, t_axis=0):
+    """
+    Test if all data for axis 1 of an array with 2 dimension are nodata
+    The function return an array with shape equal of the shape of axis 1 of the
+    orignal array `arr`. This returned array is zeros everywhere but np.nan if all
+    values of arr are nodata for axis 1.
+
+    parameter:
+    ----------
+    arr: np.array
+    nodata: float | int | np.nan
+    t_axis: array axis for time
+    """
+
+    arr = np.moveaxis(arr, t_axis, 0)
+    c_axis = 1
+
+    res_nodata = None
+    if len(arr.shape) == 2:
+        res_nodata = np.zeros(shape=(arr.shape[c_axis]))
+        for i in range(arr.shape[c_axis]):
+            if np.all(arr[:, i] <= nodata):
+                res_nodata[i] = np.nan
+
+    # print(res_nodata)
+
+    return res_nodata
+
+
+def _test_input_shape(arr):
+    """
+    Test the shape of the array `arr`
+    :param arr: np.ndarray
+    :type arr: np.ndarray
+
+    """
+
+    if len(arr.shape) > 2:
+        raise ValueError(
+            "Dimension of the input array must not be greater than 2:"
+            f"given shape is {arr.shape} with {len(arr.shape)} dimension."
+        )
+
+
+@tools.autocast_args
+def mse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria mse:
+        mse = (1.0 / nb_valid_data) * np.sum((obs - sim) ** 2.0)
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    _test_input_shape(obs)
+    _test_input_shape(sim)
+
+    mask_nodata = obs != nodata
+    nb_valid_data = np.count_nonzero(mask_nodata, axis=t_axis)
+    res_nodata = _get_mask_colum_nodata(obs, nodata=nodata, t_axis=t_axis)
+    mse = np.nan
+
+    if sum(nb_valid_data) > 0:
+
+        if isinstance(obs, np.ndarray) and isinstance(sim, np.ndarray):
+
+            if obs.shape == sim.shape:
+                mse = (1.0 / nb_valid_data) * np.sum(
+                    (obs - sim) ** 2.0, axis=t_axis, where=mask_nodata
+                )
+            else:
+                raise ValueError(f"Error: len(obs)!=len(sim), {len(obs)}!={len(sim)}")
+        else:
+            raise ValueError("Error: obs and sim must be an instance of np.ndarray")
+
+    else:
+        raise ValueError("Error: no valid observation data.")
+
+    if res_nodata is not None:
+        mse = mse + res_nodata
+
+    return mse
+
+
+@tools.autocast_args
+def sm_mse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria mse:
+        mse = (1.0 / nb_valid_data) * np.sum((obs - sim) ** 2.0)
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    """
+
+    mse = smash_metrics.mse(obs, sim)
+
+    return mse
+
+
+@tools.autocast_args
+def rmse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria rmse:
+        rmse = np.sqrt(res_mse)
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    res_mse = mse(obs, sim, nodata=nodata, t_axis=t_axis)
+
+    rmse = np.sqrt(res_mse)
+
+    return rmse
+
+
+@tools.autocast_args
+def sm_rmse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria rmse:
+        rmse = np.sqrt(res_mse)
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+
+    """
+
+    rmse = smash_metrics.rmse(obs, sim)
+
+    return rmse
+
+
+@tools.autocast_args
+def nrmse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria nrmse:
+        nrmse = res_rmse / mean_obs
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    res_rmse = rmse(obs, sim, nodata=nodata, t_axis=t_axis)
+    mask_nodata = obs != nodata
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=RuntimeWarning)
+        mean_obs = np.mean(obs, axis=t_axis, where=mask_nodata)
+
+    nrmse = res_rmse / mean_obs
+
+    return nrmse
+
+
+@tools.autocast_args
+def sm_nmse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria nrmse:
+        nrmse = res_rmse / mean_obs
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+
+    """
+
+    mask_nodata = obs < 0.0
+    mean_obs = np.nanmean(obs, where=mask_nodata)
+    mse = smash_metrics.mse(obs, sim)
+
+    return mse
+
+
+@tools.autocast_args
+def se(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria se:
+        se = (
+            np.sum((obs - sim)** 2.0, axis=t_axis, where=mask_nodata)
+        )
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    _test_input_shape(obs)
+    _test_input_shape(sim)
+
+    mask_nodata = obs != nodata
+    nb_valid_data = np.count_nonzero(mask_nodata, axis=t_axis)
+    res_nodata = _get_mask_colum_nodata(obs, nodata=nodata, t_axis=t_axis)
+    se = np.nan
+
+    if sum(nb_valid_data) > 0:
+
+        if isinstance(obs, np.ndarray) and isinstance(sim, np.ndarray):
+
+            if obs.shape == sim.shape:
+                se = np.sum((obs - sim) ** 2.0, axis=t_axis, where=mask_nodata)
+            else:
+                raise ValueError(f"Error: len(obs)!=len(sim), {len(obs)}!={len(sim)}")
+        else:
+            raise ValueError("Error: obs and sim must be an instance of np.ndarray")
+
+    else:
+        raise ValueError("Error: no valid observation data.")
+
+    if res_nodata is not None:
+        se = se + res_nodata
+
+    return se
+
+
+@tools.autocast_args
+def sm_se(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria se:
+        se = (
+            np.sum((obs - sim)** 2.0, axis=t_axis, where=mask_nodata)
+        )
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    """
+
+    se = smash_metrics.se(obs, sim)
+
+    return se
+
+
+@tools.autocast_args
+def mae(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria mae:
+        mae = 1/n*(np.sum(abs(obs - sim))
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    _test_input_shape(obs)
+    _test_input_shape(sim)
+
+    mask_nodata = obs != nodata
+    nb_valid_data = np.count_nonzero(mask_nodata, axis=t_axis)
+    res_nodata = _get_mask_colum_nodata(obs, nodata=nodata, t_axis=t_axis)
+    mae = np.nan
+
+    if sum(nb_valid_data) > 0:
+
+        if isinstance(obs, np.ndarray) and isinstance(sim, np.ndarray):
+
+            if obs.shape == sim.shape:
+                mae = (1.0 / nb_valid_data) * (
+                    np.sum(abs(obs - sim), axis=t_axis, where=mask_nodata)
+                )
+            else:
+                raise ValueError(f"Error: len(obs)!=len(sim), {len(obs)}!={len(sim)}")
+        else:
+            raise ValueError("Error: obs and sim must be an instance of np.ndarray")
+
+    else:
+        raise ValueError("Error: no valid observation data.")
+
+    if res_nodata is not None:
+        mae = mae + res_nodata
+
+    return mae
+
+
+@tools.autocast_args
+def sm_mae(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria mae:
+        mae = np.sqrt(np.sum(abs(obs - sim))
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    mae = smash_metrics.mae(obs, sim)
+
+    return mae
+
+
+@tools.autocast_args
+def mape(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria mape:
+        mape = 1/n*(
+            np.sum(abs((obs - sim) / obs))
+        )
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    _test_input_shape(obs)
+    _test_input_shape(sim)
+
+    mask_nodata = obs != nodata
+    nb_valid_data = np.count_nonzero(mask_nodata, axis=t_axis)
+    res_nodata = _get_mask_colum_nodata(obs, nodata=nodata, t_axis=t_axis)
+    mape = np.nan
+
+    if sum(nb_valid_data) > 0:
+
+        if isinstance(obs, np.ndarray) and isinstance(sim, np.ndarray):
+
+            if obs.shape == sim.shape:
+                mape = (1.0 / nb_valid_data) * (
+                    np.sum(abs((obs - sim) / obs), axis=t_axis, where=mask_nodata)
+                )
+            else:
+                raise ValueError(f"Error: len(obs)!=len(sim), {len(obs)}!={len(sim)}")
+        else:
+            raise ValueError("Error: obs and sim must be an instance of np.ndarray")
+
+    else:
+        raise ValueError("Error: no valid observation data.")
+
+    if res_nodata is not None:
+        mape = mape + res_nodata
+
+    return mape
+
+
+@tools.autocast_args
+def sm_mape(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria mape:
+        mape = np.sqrt(
+            np.sum(abs((obs - sim) / obs))
+        )
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+
+    """
+
+    mape = smash_metrics.mape(obs, sim)
+
+    return mape
+
+
+@tools.autocast_args
+def lgrm(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria lgrm:
+        lgrm = np.sum(
+            obs * (np.log((obs / sim) ** 2.0)), axis=t_axis, where=mask_nodata
+        )
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    _test_input_shape(obs)
+    _test_input_shape(sim)
+
+    mask_nodata = obs != nodata
+    nb_valid_data = np.count_nonzero(mask_nodata, axis=t_axis)
+    res_nodata = _get_mask_colum_nodata(obs, nodata=nodata, t_axis=t_axis)
+    lgrm = np.nan
+
+    if sum(nb_valid_data) > 0:
+
+        if isinstance(obs, np.ndarray) and isinstance(sim, np.ndarray):
+
+            if obs.shape == sim.shape:
+                lgrm = np.sum(
+                    obs * (np.log(sim / obs) ** 2.0), axis=t_axis, where=mask_nodata
+                )
+
+            else:
+                raise ValueError(f"Error: len(obs)!=len(sim), {len(obs)}!={len(sim)}")
+        else:
+            raise ValueError("Error: obs and sim must be an instance of np.ndarray")
+
+    else:
+        raise ValueError("Error: no valid observation data.")
+
+    if res_nodata is not None:
+        lgrm = lgrm + res_nodata
+
+    return lgrm
+
+
+@tools.autocast_args
+def sm_lgrm(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria lgrm:
+        lgrm = np.sum(
+            obs * (np.log((obs / sim) ** 2.0)), axis=t_axis, where=mask_nodata
+        )
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    """
+
+    lgrm = smash_metrics.lgrm(obs, sim)
+
+    return lgrm
+
+
+@tools.autocast_args
+def nse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria nse:
+        numerator = np.sum((obs - sim) ** 2.0, axis=t_axis, where=mask_nodata)
+
+        denominator = np.sum(
+            (obs - mean_obs) ** 2.0, axis=t_axis, where=mask_nodata
+        )
+
+        denominator = np.where(denominator == 0, np.nan, denominator)
+
+        nse = 1 - numerator / denominator
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    _test_input_shape(obs)
+    _test_input_shape(sim)
+
+    mask_nodata = obs != nodata
+    nb_valid_data = np.count_nonzero(mask_nodata, axis=t_axis)
+
+    nse = np.nan
+
+    if sum(nb_valid_data) > 0:
+
+        if isinstance(obs, np.ndarray) and isinstance(sim, np.ndarray):
+            if obs.shape == sim.shape:
+
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", category=RuntimeWarning)
+                    mean_obs = np.mean(obs, axis=t_axis, where=mask_nodata, keepdims=True)
+
+                numerator = np.sum((obs - sim) ** 2.0, axis=t_axis, where=mask_nodata)
+
+                denominator = np.sum(
+                    (obs - mean_obs) ** 2.0, axis=t_axis, where=mask_nodata
+                )
+
+                denominator = np.where(denominator == 0, np.nan, denominator)
+                nse = 1 - numerator / denominator
+            else:
+                raise ValueError(f"Error: len(obs)!=len(sim), {len(obs)}!={len(sim)}")
+        else:
+            raise ValueError("Error: obs and sim must be an instance of np.ndarray")
+
+    else:
+        raise ValueError("Error: no valid observation data.")
+
+    return nse
+
+
+@tools.autocast_args
+def sm_nse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria nse:
+        numerator = np.sum((obs - sim) ** 2.0, axis=t_axis, where=mask_nodata)
+
+        denominator = np.sum(
+            (obs - mean_obs) ** 2.0, axis=t_axis, where=mask_nodata
+        )
+
+        denominator = np.where(denominator == 0, np.nan, denominator)
+
+        nse = 1 - numerator / denominator
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+
+    """
+
+    nse = smash_metrics.nse(obs, sim)
+
+    return nse
+
+
+@tools.autocast_args
+def nnse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria nnse:
+        nnse = 1.0 / (2.0 - res_nse)
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    res_nse = nse(obs, sim, nodata=nodata, t_axis=t_axis)
+    nnse = 1.0 / (2.0 - res_nse)
+
+    return nnse
+
+
+@tools.autocast_args
+def sm_nnse(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria nnse:
+        nnse = 1.0 / (2.0 - res_nse)
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+
+    """
+
+    nnse = smash_metrics.nnse(obs, sim)
+
+    return nse
+
+
+@tools.autocast_args
+def kge(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+    nodata: float = -99.0,
+    t_axis: int = 0,
+):
+    """
+    Compute the misfit criteria kge:
+        std_obs = np.std(
+            obs, axis=t_axis, where=mask_nodata, keepdims=True, mean=mean_obs
+        )
+        std_sim = np.std(
+            sim, axis=t_axis, where=mask_nodata, keepdims=True, mean=mean_sim
+        )
+
+    beta = mean_sim / mean_obs
+
+    alpha = std_sim / std_obs
+
+    r2 = (
+        1
+        / (sim.shape[t_axis])
+        * np.sum(
+            ((sim - mean_sim) / std_sim) * ((obs - mean_obs) / std_obs),
+            axis=t_axis,
+            keepdims=True,
+        )
+    )
+
+    kge = 1 - np.sqrt(
+        (r2 - 1.0) ** 2.0 + (alpha - 1.0) ** 2.0 + (beta - 1) ** 2.0
+    )
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    :param nodata: No data value, defaults to -99.0
+    :type nodata: float, optional
+    :param t_axis: Array axis of the time, defaults to 0
+    :type t_axis: int, optional
+
+    """
+    t_axis = min(t_axis, len(obs.shape) - 1)
+    _test_input_shape(obs)
+    _test_input_shape(sim)
+
+    mask_nodata = obs != nodata
+    nb_valid_data = np.count_nonzero(mask_nodata, axis=t_axis)
+
+    kge = np.nan
+
+    if sum(nb_valid_data) > 0:
+
+        if isinstance(obs, np.ndarray) and isinstance(sim, np.ndarray):
+            if obs.shape == sim.shape:
+
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", category=RuntimeWarning)
+                    mean_obs = np.mean(obs, axis=t_axis, where=mask_nodata, keepdims=True)
+                    mean_sim = np.mean(sim, axis=t_axis, where=mask_nodata, keepdims=True)
+                    std_obs = np.std(
+                        obs, axis=t_axis, where=mask_nodata, keepdims=True, mean=mean_obs
+                    )
+                    std_sim = np.std(
+                        sim, axis=t_axis, where=mask_nodata, keepdims=True, mean=mean_sim
+                    )
+
+                mean_obs = np.where(mean_obs == 0, np.nan, mean_obs)
+                beta = mean_sim / mean_obs
+
+                std_obs = np.where(std_obs == 0, np.nan, std_obs)
+                alpha = std_sim / std_obs
+
+                # r2 = np.sum(
+                #     (sim - mean_sim) * (obs - mean_obs), axis=t_axis, keepdims=True
+                # ) / ((sim.shape[t_axis]) * (std_obs * std_sim))
+
+                r2 = (
+                    1
+                    / (sim.shape[t_axis])
+                    * np.sum(
+                        ((sim - mean_sim) / std_sim) * ((obs - mean_obs) / std_obs),
+                        axis=t_axis,
+                        keepdims=True,
+                    )
+                )
+
+                kge = 1 - np.sqrt(
+                    (r2 - 1.0) ** 2.0 + (alpha - 1.0) ** 2.0 + (beta - 1) ** 2.0
+                )
+            else:
+                raise ValueError(f"Error: len(obs)!=len(sim), {len(obs)}!={len(sim)}")
+        else:
+            raise ValueError("Error: obs and sim must be an instance of np.ndarray")
+
+    else:
+        raise ValueError("Error: no valid observation data.")
+
+    return np.squeeze(kge)
+
+
+@tools.autocast_args
+def sm_kge(
+    obs: np.ndarray | None = None,
+    sim: np.ndarray | None = None,
+):
+    """
+    Compute the misfit criteria kge, see the Smash documentation at https://smash.recover.inrae.fr/math_num_documentation/efficiency_error_metric.html
+
+    :param obs: Observed discharges, defaults to None
+    :type obs: np.ndarray | None, optional
+    :param sim: simulated discharges, defaults to None
+    :type sim: np.ndarray | None, optional
+    """
+
+    kge = smash_metrics.kge(obs, sim)
+
+    return kge
+
+
+# Fonction de calcul du débit de retour
+def quantile_gumbel(T: float = 1.0, loc: float = 0.0, scale: float = 0.0):
+    """
+    Compute the quantile for a given return period using the Gumbel law.
+    :param T: The return period, defaults to 1
+    :type T: float, optional
+    :param loc: The localisation parameter of the Gumbel law, defaults to 0.0
+    :type loc: float, optional
+    :param scale: The scale parameter of the Gumbel law, defaults to 0.0
+    :type scale: float, optional
+    :return: The value of the quantile
+    :rtype: float
+
+    """
+
+    return stats.gumbel_r.ppf(1 - 1 / T, loc=loc, scale=scale)
+
+
+# Fonction de calcul du débit de retour
+def quantile_gev(
+    T: float = 1.0, shape: float = 0.0, loc: float = 0.0, scale: float = 0.0
+):
+    """
+    Compute the quantile for a given return period using the GEV law.
+    :param T: The return period, defaults to 1
+    :type T: float, optional
+    :param shape: The shape parameter of the GEV law, defaults to 0.0
+    :type shape: float, optional
+    :param loc: The localisation parameter of the GEV law, defaults to 0.0
+    :type loc: float, optional
+    :param scale: The scale parameter of the GEV law, defaults to 0.0
+    :type scale: float, optional
+    :return: The value of the quantile
+    :rtype: float
+
+    """
+    return stats.genextreme.ppf(1 - 1 / T, shape, loc=loc, scale=scale)
+
+
+def genextreme_fit(data: np.ndarray | None = None, estimate_method: str = "MLE"):
+    """
+    Return estimates of shape, location, and scale parameters from data. The default
+     estimation method is Maximum Likelihood Estimation (MLE), but Method of Moments (MM)
+      is also available.
+    :param data: Data of maximum values used to fit a GEV, defaults to None
+    :type data: np.ndarray | None, optional
+    :param estimate_method: Method to optimize the parameters: MLE for Maximum Likelihood
+     Estimate, MM for  Method of Moments , defaults to "MLE"
+    :type estimate_method: str, optional
+    :return: Estimates for any shape parameters (if applicable), followed by those for
+     location and scale.
+    :rtype: tuple of float
+
+    """
+    if data is None:
+        raise ValueError("input data is None. You must provide valid data.")
+    res = stats.genextreme.fit(data, method=estimate_method)
+    return res
+
+
+def gumbel_r_fit(data: np.ndarray | None = None, estimate_method: str = "MLE"):
+    """
+    Return estimates of shape, location, and scale parameters from data.
+     The default estimation method is Maximum Likelihood Estimation (MLE),
+      but Method of Moments (MM) is also available.
+    :param data: Data of maximum values used to fit a Gumbel law, defaults to None
+    :type data: np.ndarray | None, optional
+    :param estimate_method: Method to optimize the parameters: MLE for Maximum Likelihood
+     Estimate, MM for  Method of Moments , defaults to "MLE"
+    :type estimate_method: str, optional
+    :return: Estimates for any shape parameters (if applicable), followed by those for
+     location and scale.
+    :rtype: tuple of float
+
+    """
+    if data is None:
+        raise ValueError("input data is None. You must provide valid data.")
+
+    res = stats.gumbel_r.fit(data, method=estimate_method)
+    return (0, *res)
+
+
+@tools.autocast_args
+def time_resample_array(
+    array: np.ndarray | None,
+    quantile_duration: int | float = 1,
+    model_time_step: float = 3600,
+    quantile_chunk_size: int | None = None,
+    t_axis: int = 2,
+):
+    """
+    Resample the discharges array for a given time-step.
+    :param array: the matrix containing the discharge with shape (nbx, nby, nbts)
+    :type array: np.ndarray | None
+    :param quantile_duration: The duration of the quantile (hours), defaults to 1
+    :type quantile_duration: int | float, optional
+    :param model_time_step: the time-step of the Smash model (seconds), defaults to 3600
+    :type model_time_step: float, optional
+    :param quantile_chunk_size: the size of the quantile chunk in days
+    :type quantile_chunk_size: int | None
+    :param t_axis: The array axis direction of the time-step, defaults to 2
+    :type t_axis: int, optional
+    :return: The resampled array
+    :rtype: np.ndarray
+
+    """
+    # R workaround as normal number (int) are passed to float to python
+    # t_axis = int(t_axis)
+
+    # resample array to the new duration
+    if pd.Timedelta(hours=quantile_duration) > pd.Timedelta(seconds=model_time_step):
+        print(
+            f"</> Resampling array with time-step `{pd.Timedelta(seconds=model_time_step)}`"
+            f" to time-step `{pd.Timedelta(hours=quantile_duration)}`"
+        )
+        chunk_size = int(
+            pd.Timedelta(hours=quantile_duration) / pd.Timedelta(seconds=model_time_step)
+        )
+
+        array_trans = np.moveaxis(array, t_axis, 0)  # Axe à la position 0
+
+        new_shape = (array_trans.shape[0] // chunk_size, chunk_size) + array_trans.shape[
+            1:
+        ]
+
+        array_trans_reshaped = array_trans[
+            0 : chunk_size * (array_trans.shape[0] // chunk_size)
+        ].reshape(new_shape)
+
+        array_trans_reshaped_mean = np.mean(array_trans_reshaped, axis=1)
+
+        if quantile_chunk_size is None:
+            remainder = array_trans.shape[0] % chunk_size
+        else:
+            # The final shape must be extended only if it is not a multiple of quantile_chunk_size.
+            remainder = (
+                array_trans_reshaped_mean.shape[0]
+                * pd.Timedelta(hours=quantile_duration)
+                % pd.Timedelta(days=quantile_chunk_size)
+            ).total_seconds()
+
+        del array_trans
+
+        if remainder > 0:
+            # extend the array with the previous value
+            array_trans_reshaped_mean = np.insert(
+                array_trans_reshaped_mean,
+                obj=-1,
+                axis=0,
+                values=array_trans_reshaped_mean[-1, :],
+            )
+
+        del array_trans_reshaped
+
+        array = np.moveaxis(array_trans_reshaped_mean, 0, t_axis)
+
+        del array_trans_reshaped_mean
+
+    return array
+
+
+@tools.autocast_args
+def compute_maxima(
+    array: np.ndarray | None,
+    t_axis: int = 2,
+    nb_minimum_chunks: int = 4,
+    chunk_size: int = 365,
+    quantile_duration: int | float = 1,
+):
+    """
+    Compute the maxima of the discharges for a given chunk_size in the t_axis direction.
+    :param array: the matrix containing the discharge with shape (nbx, nby, nbts). The
+    shape can be smaller or higher. But t_axis must be set to target the nbts
+    (number of time-step) dimension. Ex: if shape=(nbx, nbts), t_axis must be equal to 1.
+    :type array: np.ndarray | None
+    :param t_axis: The array axis direction of the time-step, defaults to 2, defaults to 2
+    :type t_axis: int, optional
+    :param nb_minimum_chunks: minimal number of chunk required adjust an extrem law and
+    compute the quantile, defaults to 4
+    :type nb_minimum_chunks: int, optional
+    :param chunk_size: The chunk_size (days). It correspond to the 'unit' of the
+    return period, defaults to 365 (year)
+    :type chunk_size: int, optional
+    :param quantile_duration: The duration of the quantile (hour), defaults to 1
+    :type quantile_duration: int | float, optional
+    :return: an np.ndarray of spatial maximal values for every chunk
+    :rtype: np.ndarray
+
+    """
+
+    if pd.Timedelta(
+        hours=quantile_duration,
+    ) > pd.Timedelta(
+        days=chunk_size,
+    ):
+        raise ValueError(
+            "The chunk_size {chunk_size} (days) must be"
+            " greater than the quantile duration {quantile_duration} (hours)"
+        )
+
+    # compute the nb of chunk in the input data
+    nbchunks = int(
+        array.shape[t_axis]
+        * pd.Timedelta(hours=quantile_duration)
+        / pd.Timedelta(days=chunk_size)
+    )
+    print(f"</> Data contain {nbchunks} chunks of {pd.Timedelta(days=chunk_size)}")
+
+    nb_ts_by_chunk = int(array.shape[t_axis] / nbchunks)
+
+    if nbchunks < nb_minimum_chunks:
+        raise ValueError(
+            "</> The number of simulated chunks is not enough to compute the quantile:"
+            f" {nbchunks}<{nb_minimum_chunks}"
+        )
+
+    # nb year limit to compute the quantile
+    if nbchunks >= nb_minimum_chunks:
+        print(
+            f"</> Compute the maxima for every chunk with size"
+            f" {nb_ts_by_chunk} time-steps"
+            f" of {quantile_duration} hours."
+        )
+        out_shape = []
+        list_axes = []
+        for nshape in range(len(array.shape)):
+            out_shape.append(0)
+            list_axes.append(nshape)
+
+        out_shape[t_axis] = nbchunks
+        list_axes.remove(t_axis)
+
+        for ax in list_axes:
+            out_shape[ax] = array.shape[ax]
+
+        maxima = np.zeros(shape=out_shape)
+
+        nb_ts_by_chunk = int(array.shape[t_axis] / nbchunks)
+        remainder = array.shape[t_axis] % nbchunks
+        pos = 0
+
+        # original_axis = [i for i in range(len(array.shape))]
+        # other_axis = original_axis.copy()
+        # other_axis.remove(t_axis)
+        # destination_axis = [original_axis[t_axis]] + other_axis
+
+        # print(original_axis, destination_axis)
+
+        # print(maxima.shape)
+        # print(array.shape)
+        # move_axis first to extend the possibiltiy to use this function with different array shape
+        array = np.moveaxis(array, t_axis, 0)
+        maxima = np.moveaxis(maxima, t_axis, 0)
+        # print(maxima.shape)
+        # print(array.shape)
+        for i in range(nbchunks):
+            # Alternate one more cell because nb_ts_by_chunk is not a factor of array.shape[t_axis]
+            if i % 2 > 0 and remainder > 0:
+                onemore = 1
+            else:
+                onemore = 0
+
+            # maxima[:, :, i] = np.max(
+            #     array[:, :, int(i * nb_ts_by_chunk) : int((i + 1) * nb_ts_by_chunk)],
+            #     axis=t_axis,
+            # )
+            # print(array.shape, pos, int(pos + nb_ts_by_chunk + onemore))
+            # maxima[:, :, i] = np.max(
+            #     array[:, :, pos : int(pos + nb_ts_by_chunk + onemore)],
+            #     axis=t_axis,
+            # )
+
+            # Check if value >-99 and check if nb lacuna <20% ? Or remove lowers maxima after all (10%)
+            # if (array[pos : int(pos + nb_ts_by_chunk + onemore), :])
+
+            maxima[i, :] = np.max(
+                array[pos : int(pos + nb_ts_by_chunk + onemore), :],
+                axis=0,
+            )
+            pos = int(pos + nb_ts_by_chunk + onemore)
+
+        array = np.moveaxis(array, 0, t_axis)
+        maxima = np.moveaxis(maxima, 0, t_axis)
+
+    return maxima
+
+
+def quantil_obs(
+    qobs_directory: str | None = None,
+    code: np.ndarray | list = [],
+    model_time_step: float = 3600,
+    nb_minimum_chunks: int = 4,
+    chunk_size: int = 365,
+    quantile_duration: int = 1,
+):
+
+    if qobs_directory is None:
+        print("</> qobs_directory `{qobs_directory}` is not a valid directory")
+        return
+
+    if isinstance(code, list):
+        code = np.array(code)
+
+    qobs = tools.read_hourly_qobs(qobs_directory, code)
+
+    array = time_resample_array(
+        array=qobs,
+        quantile_duration=quantile_duration,
+        model_time_step=model_time_step,
+        quantile_chunk_size=chunk_size,
+        t_axis=1,
+    )
+
+    maxima = compute_maxima(
+        array=array,
+        t_axis=1,
+        nb_minimum_chunks=nb_minimum_chunks,
+        chunk_size=chunk_size,
+        quantile_duration=quantile_duration,
+    )
+
+    results = empirical_obs_quantile(
+        maxima=maxima,
+        nb_minimum_chunks=nb_minimum_chunks,
+        chunk_size=chunk_size,
+        quantile_duration=quantile_duration,
+    )
+
+    return results
+
+
+def empirical_obs_quantile(
+    maxima: np.ndarray | None,
+    t_axis=1,
+    nb_minimum_chunks: int = 4,
+    frac_to_remove: float = 0.1,
+    quantile_duration: int | float = 1,
+    chunk_size: int = 365,
+):
+    """
+    :param maxima: Maximal discharge by chunk
+    :type maxima: np.ndarray | None
+    :param t_axis: axis of the time series, defaults to 1
+    :type t_axis: TYPE, optional
+    :param nb_minimum_chunks: number of minimum chunck required to remove `frac_to_remove` of the maxima distribution, i.e len of the maxima array in the t_axis direction, defaults to 4
+    :type nb_minimum_chunks: int, optional
+    :param frac_to_remove: fraction between 0 and 1 to remove lower value of the maxima distribution, incase of incomplete data chunk, defaults to 0.1
+    :type frac_to_remove: float, default 0.1
+    :param quantile_duration: duration of the quantile (hour)
+    :type quantile_duration int | float, default 1
+    :param chunk_size: size of the chunk used to comute the maxima
+    :type chunk_size: int, default 365
+    """
+
+    maxima = np.moveaxis(maxima, t_axis, 0)
+    maxima_sorted = np.sort(maxima, axis=0)
+    maxima_sorted = np.where(maxima_sorted < 0, np.nan, maxima_sorted)
+    T_emp = np.zeros(shape=maxima.shape) + np.nan
+    # n = maxima.shape[0]
+
+    for sta in range(maxima_sorted.shape[1]):
+        n_valid = np.where(maxima_sorted[:, sta] > 0)
+        n = len(n_valid[0])
+        # remove 10% of the
+        if n > nb_minimum_chunks:
+            n_to_remove = max(1, int(frac_to_remove * n))
+        else:
+            n_to_remove = 0
+
+        for i in range(n_to_remove):
+            ind = n_valid[0][i]
+            maxima_sorted[i] = np.nan
+
+        if n > nb_minimum_chunks:
+            rank = 1
+            for i in range(n_to_remove, n):
+                probs = (rank - 0.5) / n
+                T_emp[n_valid[0][i], sta] = 1 / (1 - probs)
+                rank = rank + 1
+
+    # trim/filter nan cells
+    index = []
+    for t in range(maxima_sorted.shape[0]):
+        if np.any(maxima_sorted[t, :] >= 0):
+            index.append(t)
+
+    maxima_sorted = maxima_sorted[index, :]
+    T_emp = T_emp[index, :]
+
+    maxima_sorted = np.moveaxis(maxima_sorted, 0, t_axis)
+    T_emp = np.moveaxis(T_emp, 0, t_axis)
+
+    results = {
+        "maxima": maxima_sorted,
+        "Temp": T_emp,
+        "chunk_size": chunk_size,
+        "nb_chunks": maxima.shape[t_axis],
+        "quantile_duration": quantile_duration,
+    }
+    return results
+
+
+@tools.autocast_args
+def fit_quantile(
+    maxima: np.ndarray | None,
+    t_axis: int = 2,
+    return_periods: list | tuple = [2, 5, 10, 20, 50, 100],
+    fit: str = "gumbel",
+    estimate_method: str = "MLE",
+    quantile_duration: int | float = 1,
+    chunk_size: int = 365,
+    ncpu: int | None = None,
+):
+    """
+    Proceed to the qunaitle adjustment.
+    :param maxima: an np.ndarray of spatial maximal values for every chunk
+    :type maxima: np.ndarray | None
+    :param t_axis: The array axis direction of the time-step, defaults to 2,
+    defaults to 2, defaults to 2
+    :type t_axis: int, optional
+    :param return_periods: A list of the return period, defaults to [2, 5, 10, 20, 50, 100]
+    :type return_periods: list | tuple, optional
+    :param fit: The extrem law to use (gumbel or gev), defaults to "gumbel"
+    :type fit: str, optional
+    :param estimate_method: The methode to use for calibrated the parameters
+    of the extrem law (MLE or MM), defaults to "MLE"
+    :type estimate_method: str, optional
+    :param quantile_duration: The duration of the quantile (hour), defaults to 1
+    :type quantile_duration: int | float, optional
+    :param chunk_size: the size of the chunks in days, defaults to 365
+    :type chunk_size: int, optional
+    :param ncpu: Number of cpu to use, defaults to None
+    :type ncpu: int | None, optional
+    :return: A dictionary containing the results od the quantile computation:
+     Results include the quantile, the empirical return period,
+     the maxima for each chunk of chunk_size, the fit parameters of the `fit` extrem law.
+    :rtype: dict
+
+    """
+
+    if ncpu is None:
+        ncpu = int(os.cpu_count() / 2)
+    else:
+        ncpu = int(min(ncpu, os.cpu_count() - 1))
+
+    if len(maxima.shape) < 2 or len(maxima.shape) > 3:
+        raise ValueError(
+            f"Input array `maxima` must have a dimension of 2 or 3. "
+            f"Actual input have a dimension of {len(maxima.shape)} with shape {maxima.shape}"
+        )
+
+    grid_shape = list(maxima.shape)
+    del grid_shape[t_axis]
+
+    fit_shape = np.zeros(shape=grid_shape)
+    fit_loc = np.zeros(shape=grid_shape)
+    fit_scale = np.zeros(shape=grid_shape)
+    quantile = np.zeros(shape=grid_shape + [len(return_periods)]) * np.nan
+
+    # list_axes = [ax for ax in range(len(maxima.shape))]
+    # list_axes.remove(t_axis)
+
+    # fit_shape = np.zeros(shape=(maxima.shape[list_axes[0]], maxima.shape[list_axes[1]]))
+    # fit_loc = np.zeros(shape=(maxima.shape[list_axes[0]], maxima.shape[list_axes[1]]))
+    # fit_scale = np.zeros(shape=(maxima.shape[list_axes[0]], maxima.shape[list_axes[1]]))
+
+    # quantile = (
+    #     np.zeros(
+    #         shape=(
+    #             maxima.shape[list_axes[0]],
+    #             maxima.shape[list_axes[1]],
+    #             len(return_periods),
+    #         )
+    #     )
+    #     * np.nan
+    # )
+
+    # Total length of the grid, linearize the matrix => 1 dim
+    nd = 1
+    for d in grid_shape:
+        nd = nd * d
+
+    original_shape = maxima.shape
+    newshape = (nd, maxima.shape[-1])
+
+    maxima = maxima.reshape(newshape)
+    fit_shape = fit_shape.reshape(nd)
+    fit_loc = fit_loc.reshape(nd)
+    fit_scale = fit_scale.reshape(nd)
+    quantile = quantile.reshape((nd, len(return_periods)))
+
+    print(f"</> Fitting {fit} law on data using {estimate_method} method.")
+
+    pool = multiprocessing.Pool(ncpu)
+
+    # Split by chunk to display a progress bar. chunk have the size of cpu
+    chunksize = ncpu
+    nbchunk = int(maxima.shape[0] / chunksize)
+
+    for chunk in tqdm(range(nbchunk + 1)):
+
+        args = []
+        index_i = []
+
+        for i in range(chunk * chunksize, chunk * chunksize + chunksize):
+
+            if i >= nd:
+                break
+
+            if np.all(maxima[i, :] > 0.0):
+                args.append((maxima[i, :], estimate_method))
+                index_i.append(i)
+
+        if fit == "gumbel":
+            res = pool.starmap(gumbel_r_fit, args, chunksize=1)
+
+        if fit == "gev":
+            res = pool.starmap(genextreme_fit, args, chunksize=1)
+
+        k = 0
+        for item in res:
+            i = index_i[k]
+            fit_shape[i] = item[0]
+            fit_loc[i] = item[1]
+            fit_scale[i] = item[2]
+
+            for index, T in enumerate(return_periods):
+                if fit == "gumbel":
+                    quantile[i, index] = quantile_gumbel(T, item[1], item[2])
+                if fit == "gev":
+                    quantile[i, index] = quantile_gev(T, item[0], item[1], item[2])
+
+            k = k + 1
+
+    maxima = maxima.reshape(original_shape)
+    fit_shape = fit_shape.reshape(grid_shape)
+    fit_loc = fit_loc.reshape(grid_shape)
+    fit_scale = fit_scale.reshape(grid_shape)
+    quantile = quantile.reshape(grid_shape + [len(return_periods)])
+
+    # pool = multiprocessing.Pool(ncpu)
+
+    # print(f"</> Fitting {fit} law on data using {estimate_method} method.")
+
+    # for i in tqdm(range(maxima.shape[list_axes[0]])):
+
+    #     args = []
+    #     index_j = []
+
+    #     for j in range(maxima.shape[list_axes[1]]):
+    #         if np.all(maxima[i, j, :] > 0.0):
+    #             args.append((maxima[i, j, :], estimate_method))
+    #             index_j.append(j)
+
+    #     if fit == "gumbel":
+    #         res = pool.starmap(gumbel_r_fit, args, chunksize=1)
+
+    #     if fit == "gev":
+    #         res = pool.starmap(genextreme_fit, args, chunksize=1)
+
+    #     k = 0
+    #     for item in res:
+
+    #         j = index_j[k]
+
+    #         fit_shape[i, j] = item[0]
+    #         fit_loc[i, j] = item[1]
+    #         fit_scale[i, j] = item[2]
+
+    #         for index, T in enumerate(return_periods):
+    #             if fit == "gumbel":
+    #                 quantile[i, j, index] = quantile_gumbel(T, item[1], item[2])
+    #             if fit == "gev":
+    #                 quantile[i, j, index] = quantile_gev(T, item[0], item[1], item[2])
+
+    #         k = k + 1
+
+    pool.close()
+    pool.terminate()
+
+    n = maxima.shape[t_axis]
+    ranks = np.arange(1, n + 1)
+    # probs = (ranks - 0.44) / (n + 0.12)
+    probs = (ranks - 0.5) / n
+    T_emp = 1 / (1 - probs)
+
+    results = {
+        "T": np.array(return_periods),
+        "Q_th": quantile,
+        "T_emp": T_emp,
+        "maxima": maxima,
+        "nb_chunks": maxima.shape[t_axis],
+        "fit": fit,
+        "fit_loc": fit_loc,
+        "fit_scale": fit_scale,
+        "fit_shape": fit_shape,
+        "duration": quantile_duration,
+        "chunk_size": chunk_size,
+    }
+
+    return results
+
+
+@tools.autocast_args
+def parametric_bootstrap_uncertainties(
+    q_results: dict | None,
+    bootstrap_sample=100,
+    estimate_method: str = "MLE",
+    ncpu: int | None = None,
+):
+    """
+    Proceed to the qunaitle adjustment.
+    :param q_results: A dictionary containing the results of the quantile adjustment
+    :type q_results: dict | None
+    :param bootstrap_sample: the number of bootstrap sample, defaults to 100
+    :type bootstrap_sample: int, optional
+    :param estimate_method: The methode to use for calibrated the parameters
+    of the extrem law (MLE or MM), defaults to "MLE"
+    :type estimate_method: str, optional
+    :param ncpu: Number of cpu to use, defaults to None
+    :type ncpu: int | None, optional
+    :return: A dictionary containing the results od the quantile computation:
+     Results include the quantile, the empirical return period,
+     the maxima for each chunk of chunk_size, the fit parameters of the `fit` extrem law.
+    :rtype: dict
+
+    """
+    # R workaround as normal number (int) are passed to float to python
+    # ncpu = int(ncpu)
+
+    if ncpu is None:
+        ncpu = int(os.cpu_count() / 2)
+    else:
+        ncpu = min(ncpu, os.cpu_count() - 1)
+
+    sample_size = q_results["nb_chunks"]
+    quantile = q_results["Q_th"]
+    fit_loc = q_results["fit_loc"]
+    fit_scale = q_results["fit_scale"]
+    fit_shape = q_results["fit_shape"]
+
+    grid_shape = list(quantile.shape)
+    del grid_shape[-1]  # remove last dimension (return period)
+
+    parametric_quantile = (
+        np.zeros(
+            shape=(
+                *grid_shape,
+                len(q_results["T"]),
+                bootstrap_sample,
+            )
+        )
+        * np.nan
+    )
+
+    nd = 1
+    for d in grid_shape:
+        nd = nd * d
+
+    # original_shape = parametric_quantile.shape
+    newshape = (nd, len(q_results["T"]), bootstrap_sample)
+
+    parametric_quantile = parametric_quantile.reshape(newshape)
+    fit_shape = fit_shape.reshape(nd)
+    fit_loc = fit_loc.reshape(nd)
+    fit_scale = fit_scale.reshape(nd)
+    quantile = quantile.reshape(nd, len(q_results["T"]))
+
+    print(f"</> Compute bootstrap uncertainties...")
+
+    pool = multiprocessing.Pool(ncpu)
+
+    for i in tqdm(range(nd)):
+
+        if np.all(quantile[i, :] > 0.0):
+
+            args = []
+            index_k = []
+            for k in range(bootstrap_sample):
+
+                # generate sample
+                if q_results["fit"] == "gumbel":
+                    random_q = stats.gumbel_r.rvs(
+                        loc=fit_loc[i],
+                        scale=fit_scale[i],
+                        size=sample_size,
+                    )
+                if q_results["fit"] == "gev":
+                    random_q = stats.genextreme_fit.rvs(
+                        fit_shape[i],
+                        loc=fit_loc[i],
+                        scale=fit_scale[i],
+                        size=sample_size,
+                    )
+
+                args.append((random_q, q_results["fit"]))
+                index_k.append(k)
+
+            if q_results["fit"] == "gumbel":
+                res = pool.starmap(gumbel_r_fit, args, chunksize=1)
+
+            if q_results["fit"] == "gev":
+                res = pool.starmap(genextreme_fit, args, chunksize=1)
+
+            for k, item in enumerate(res):
+
+                ik = index_k[k]
+
+                for indexT, T in enumerate(q_results["T"]):
+                    if q_results["fit"] == "gumbel":
+                        parametric_quantile[i, indexT, ik] = quantile_gumbel(
+                            T, item[1], item[2]
+                        )
+                    if q_results["fit"] == "gev":
+                        parametric_quantile[i, indexT, ik] = quantile_gev(
+                            T, item[0], item[1], item[2]
+                        )
+
+    Umax = np.max(parametric_quantile, axis=2)
+    Umin = np.min(parametric_quantile, axis=2)
+
+    Umax = Umax.reshape(grid_shape + [len(q_results["T"])])
+    Umin = Umin.reshape(grid_shape + [len(q_results["T"])])
+
+    # parametric_quantile = parametric_quantile.reshape(original_shape)
+    # fit_shape = fit_shape.reshape(grid_shape)
+    # fit_loc = fit_loc.reshape(grid_shape)
+    # fit_scale = fit_scale.reshape(grid_shape)
+    # quantile = quantile.reshape(grid_shape + [len(q_results["T"])])
+
+    ##############################################"
+    # for i in tqdm(range(q_results["Q_th"].shape[0])):
+    #     for j in range(q_results["Q_th"].shape[1]):
+
+    #         if np.all(q_results["Q_th"][i, j] > 0.0):
+
+    #             args = []
+    #             index_k = []
+    #             for k in range(bootstrap_sample):
+
+    #                 # generate sample
+    #                 if q_results["fit"] == "gumbel":
+    #                     random_q = stats.gumbel_r.rvs(
+    #                         loc=q_results["fit_loc"][i, j],
+    #                         scale=q_results["fit_scale"][i, j],
+    #                         size=sample_size,
+    #                     )
+    #                 if q_results["fit"] == "gev":
+    #                     random_q = stats.genextreme_fit.rvs(
+    #                         q_results["fit_shape"][i, j],
+    #                         loc=q_results["fit_loc"][i, j],
+    #                         scale=q_results["fit_scale"][i, j],
+    #                         size=sample_size,
+    #                     )
+
+    #                 args.append((random_q, q_results["fit"]))
+    #                 index_k.append(k)
+
+    #             if q_results["fit"] == "gumbel":
+    #                 res = pool.starmap(gumbel_r_fit, args, chunksize=1)
+
+    #             if q_results["fit"] == "gev":
+    #                 res = pool.starmap(genextreme_fit, args, chunksize=1)
+
+    #             # k = 0
+    #             for k, item in enumerate(res):
+
+    #                 ik = index_k[k]
+
+    #                 for indexT, T in enumerate(return_periods):
+    #                     if q_results["fit"] == "gumbel":
+    #                         parametric_quantile[i, j, indexT, ik] = quantile_gumbel(
+    #                             T, item[1], item[2]
+    #                         )
+    #                     if q_results["fit"] == "gev":
+    #                         parametric_quantile[i, j, indexT, ik] = quantile_gev(
+    #                             T, item[0], item[1], item[2]
+    #                         )
+
+    pool.close()
+    pool.terminate()
+
+    q_results.update({"Umax": Umax, "Umin": Umin})
+
+    return q_results
+
+
+@tools.autocast_args
+def fit_quantile_unparallel(
+    maxima: np.ndarray | None,
+    t_axis: int = 2,
+    return_periods: list | tuple = [2, 5, 10, 20, 50, 100],
+    fit: str = "gumbel",
+    estimate_method: str = "MLE",
+    quantile_duration: int | float = 1.0,
+    chunk_size: int = 365,
+):
+    """
+    Proceed to the qunaitle adjustment (unparrallel computation).
+    :param maxima: an np.ndarray of spatial maximal values for every chunk
+    :type maxima: np.ndarray | None
+    :param t_axis: The array axis direction of the time-step, defaults to 2,
+    defaults to 2, defaults to 2
+    :type t_axis: int, optional
+    :param return_periods: A list of the return period, defaults to [2, 5, 10, 20, 50, 100]
+    :type return_periods: list | tuple, optional
+    :param fit: The extrem law to use (gumbel or gev), defaults to "gumbel"
+    :type fit: str, optional
+    :param estimate_method: The methode to use for calibrated the parameters
+    of the extrem law (MLE or MM), defaults to "MLE"
+    :type estimate_method: str, optional
+    :param quantile_duration: The duration of the quantile (hour), defaults to 1
+    :type quantile_duration: int | float, optional
+    :param chunk_size: the size of the chunks in days, defaults to 365
+    :type chunk_size: int, optional
+    :return: A dictionary containing the results od the quantile computation:
+     Results include the quantile, the empirical return period,
+     the maxima for each chunk of chunk_size, the fit parameters of the `fit` extrem law.
+    :rtype: dict
+
+    """
+    # # R workaround as normal number (int) are passed to float to python
+    # t_axis = int(t_axis)
+    # chunk_size = int(chunk_size)
+
+    list_axes = [0, 1, 2]
+    list_axes.remove(t_axis)
+
+    fit_shape = np.zeros(shape=(maxima.shape[list_axes[0]], maxima.shape[list_axes[1]]))
+    fit_loc = np.zeros(shape=(maxima.shape[list_axes[0]], maxima.shape[list_axes[1]]))
+    fit_scale = np.zeros(shape=(maxima.shape[list_axes[0]], maxima.shape[list_axes[1]]))
+
+    quantile = (
+        np.zeros(
+            shape=(
+                maxima.shape[list_axes[0]],
+                maxima.shape[list_axes[1]],
+                len(return_periods),
+            )
+        )
+        * np.nan
+    )
+
+    print(f"</> Fitting {fit} law on data using {estimate_method} method.")
+
+    for i in range(maxima.shape[list_axes[0]]):
+
+        for j in range(maxima.shape[list_axes[1]]):
+
+            if np.all(maxima[i, j, :] > 0.0):
+
+                if fit == "gumbel":
+                    res = gumbel_r_fit(maxima[i, j, :], estimate_method)
+
+                if fit == "gev":
+                    res = genextreme_fit(maxima[i, j, :], estimate_method)
+
+                fit_shape[i, j] = res[0]
+                fit_loc[i, j] = res[1]
+                fit_scale[i, j] = res[2]
+
+                for index, T in enumerate(return_periods):
+                    if fit == "gumbel":
+                        quantile[i, j, index] = quantile_gumbel(T, res[1], res[2])
+                    if fit == "gev":
+                        quantile[i, j, index] = quantile_gev(T, res[0], res[1], res[2])
+
+    n = maxima.shape[t_axis]
+    ranks = np.arange(1, n + 1)
+    # probs = (ranks - 0.44) / (n + 0.12)
+    probs = (ranks - 0.5) / n
+    T_emp = 1 / (1 - probs)
+
+    results = {
+        "T": np.array(return_periods),
+        "Q_th": quantile,
+        "T_emp": T_emp,
+        "maxima": maxima,
+        "nb_chunks": maxima.shape[t_axis],
+        "fit": fit,
+        "fit_loc": fit_loc,
+        "fit_scale": fit_scale,
+        "fit_shape": fit_shape,
+        "duration": quantile_duration,
+        "chunk_size": chunk_size,
+    }
+
+    return results
+
+
+@tools.autocast_args
+def parametric_bootstrap_uncertainties_unparallel(
+    q_results: dict | None,
+    bootstrap_sample=100,
+    return_periods: list | tuple = [2, 5, 10, 20, 50, 100],
+    estimate_method: str = "MLE",
+):
+    """
+    Proceed to the qunaitle adjustment.
+    :param q_results: A dictionary containing the results of the quantile adjustment
+    :type q_results: dict | None
+    :param bootstrap_sample: the number of bootstrap sample, defaults to 100
+    :type bootstrap_sample: int, optional
+    :param return_periods: A list of the return period, defaults to [2, 5, 10, 20, 50, 100]
+    :type return_periods: list | tuple, optional
+    :param estimate_method: The methode to use for calibrated the parameters
+    of the extrem law (MLE or MM), defaults to "MLE"
+    :type estimate_method: str, optional
+    :return: A dictionary containing the results od the quantile computation:
+     Results include the quantile, the empirical return period,
+     the maxima for each chunk of chunk_size, the fit parameters of the `fit` extrem law.
+    :rtype: dict
+
+    """
+
+    sample_size = q_results["nb_chunks"]
+
+    parametric_quantile = (
+        np.zeros(
+            shape=(
+                q_results["Q_th"].shape[0],
+                q_results["Q_th"].shape[1],
+                len(q_results["T"]),
+                bootstrap_sample,
+            )
+        )
+        * np.nan
+    )
+
+    for i in tqdm(range(q_results["Q_th"].shape[0])):
+        for j in range(q_results["Q_th"].shape[1]):
+
+            if np.all(q_results["Q_th"][i, j] > 0.0):
+
+                for k in range(bootstrap_sample):
+
+                    # generate sample
+                    if q_results["fit"] == "gumbel":
+                        random_q = stats.gumbel_r.rvs(
+                            loc=q_results["fit_loc"][i, j],
+                            scale=q_results["fit_scale"][i, j],
+                            size=sample_size,
+                        )
+                    if q_results["fit"] == "gev":
+                        random_q = stats.genextreme_fit.rvs(
+                            q_results["shape_loc"][i, j],
+                            loc=q_results["fit_loc"][i, j],
+                            scale=q_results["fit_scale"][i, j],
+                            size=sample_size,
+                        )
+
+                    if q_results["fit"] == "gumbel":
+                        res = gumbel_r_fit(random_q, estimate_method)
+
+                    if q_results["fit"] == "gev":
+                        res = genextreme_fit(random_q, estimate_method)
+
+                    for indexT, T in enumerate(return_periods):
+                        if q_results["fit"] == "gumbel":
+                            parametric_quantile[i, j, indexT, k] = quantile_gumbel(
+                                T, res[1], res[2]
+                            )
+                        if q_results["fit"] == "gev":
+                            parametric_quantile[i, j, indexT, k] = quantile_gev(
+                                T, res[0], res[1], res[2]
+                            )
+
+    Umax = np.max(parametric_quantile, axis=3)
+    Umin = np.min(parametric_quantile, axis=3)
+
+    q_results.update({"Umax": Umax, "Umin": Umin})
+
+    return q_results
+
+
+@tools.autocast_args
+def spatial_quantiles(
+    array: np.ndarray | None,
+    t_axis: int = 2,
+    return_periods: list | tuple = [2, 5, 10, 20, 50, 100],
+    fit: str = "gumbel",
+    nb_minimum_chunks: int = 4,
+    model_time_step: float = 3600,
+    estimate_method: str = "MLE",
+    chunk_size: int = 365,
+    quantile_duration: int | float = 1,
+    ncpu: int | None = None,
+    compute_uncertainties=False,
+    bootstrap_sample=100,
+    maxima: np.ndarray | None = None,
+):
+    """
+    Proceed to the quantile adjustment (parrallel computation).
+    :param array: an np.ndarray of spatial dicharges values for every time-step
+    :type array: np.ndarray | None
+    :param t_axis: The array axis direction of the time-step, defaults to 2,
+    defaults to 2, defaults to 2
+    :type t_axis: int, optional
+    :param return_periods: A list of the return period, defaults to [2, 5, 10, 20, 50, 100]
+    :type return_periods: list | tuple, optional
+    :param fit: The extrem law to use (gumbel or gev), defaults to "gumbel"
+    :type fit: str, optional
+    :param estimate_method: The methode to use for calibrated the parameters
+    of the extrem law (MLE or MM), defaults to "MLE"
+    :type estimate_method: str, optional
+    :param quantile_duration: The duration of the quantile (hour), defaults to 1
+    :type quantile_duration: int | float, optional
+    :param chunk_size: the size of the chunks in days, defaults to 365
+    :type chunk_size: int, optional
+    :param ncpu: Number of cpu to use, defaults to None
+    :type ncpu: int | None, optional
+    :param compute_uncertainties: Compute the uncertainties usung the parametric bootstrap method
+    :type compute_uncertainties: bool, True
+    :param bootstrap_sample: the size of bootstrap sample, default is 100
+    :type bootstrap_sample: int, optional
+    :return: A dictionary containing the results od the quantile computation:
+     Results include the quantile, the empirical return period,
+     the maxima for each chunk of chunk_size, the fit parameters of the `fit` extrem law.
+    :rtype: dict
+
+    """
+    # # R workaround as normal number (int) are passed to float to python
+    # t_axis = int(t_axis)
+    # chunk_size = int(chunk_size)
+
+    if ncpu is None:
+        ncpu = int(os.cpu_count() / 2)
+    else:
+        ncpu = int(min(ncpu, os.cpu_count() - 1))
+
+    if pd.Timedelta(
+        hours=quantile_duration,
+    ) < pd.Timedelta(
+        seconds=model_time_step,
+    ):
+        raise ValueError(
+            "The quantile duration {quantile_duration} (hours) must be"
+            "greater or equal than the model time step {model_time_step} (seconds)"
+        )
+
+    if pd.Timedelta(
+        hours=quantile_duration,
+    ) > pd.Timedelta(
+        days=chunk_size,
+    ):
+        raise ValueError(
+            "The chunk_size {chunk_size} (days) must be"
+            " greater or equal than the quantile duration {quantile_duration} (hours)"
+        )
+
+    if array is None:
+        raise ValueError("Input array is None, no data to compute quantile.")
+
+    if maxima is None:
+        array = time_resample_array(
+            array=array,
+            quantile_duration=quantile_duration,
+            model_time_step=model_time_step,
+            quantile_chunk_size=chunk_size,
+            t_axis=t_axis,
+        )
+
+        maxima = compute_maxima(
+            array=array,
+            t_axis=t_axis,
+            nb_minimum_chunks=nb_minimum_chunks,
+            chunk_size=chunk_size,
+            quantile_duration=quantile_duration,
+        )
+
+    results = fit_quantile(
+        maxima=maxima,
+        t_axis=t_axis,
+        return_periods=return_periods,
+        fit=fit,
+        estimate_method=estimate_method,
+        quantile_duration=quantile_duration,
+        chunk_size=chunk_size,
+        ncpu=ncpu,
+    )
+
+    if compute_uncertainties:
+        # calcul des incertitudes méthode bootstrap
+        results = parametric_bootstrap_uncertainties(
+            q_results=results,
+            bootstrap_sample=bootstrap_sample,
+            estimate_method=estimate_method,
+            ncpu=ncpu,
+        )
+
+    return results
+
+
+@tools.autocast_args
+def spatial_quantiles_unparallel(
+    array: np.ndarray | None = None,
+    t_axis: int = 2,
+    return_periods: list | tuple = [2, 5, 10, 20, 50, 100],
+    fit: str = "gumbel",
+    nb_minimum_chunks: int = 4,
+    model_time_step: float = 3600,
+    estimate_method: str = "MLE",
+    chunk_size: int = 365,
+    compute_uncertainties=False,
+    bootstrap_sample=100,
+    quantile_duration: int | float = 1,
+    maxima: np.ndarray | None = None,
+):
+    """
+    Proceed to the quantile adjustment (unparrallel computation).
+    :param array: an np.ndarray of spatial dicharges values for every time-step
+    :type array: np.ndarray | None
+    :param t_axis: The array axis direction of the time-step, defaults to 2,
+    defaults to 2, defaults to 2
+    :type t_axis: int, optional
+    :param return_periods: A list of the return period, defaults to [2, 5, 10, 20, 50, 100]
+    :type return_periods: list | tuple, optional
+    :param fit: The extrem law to use (gumbel or gev), defaults to "gumbel"
+    :type fit: str, optional
+    :param estimate_method: The methode to use for calibrated the parameters
+    of the extrem law (MLE or MM), defaults to "MLE"
+    :type estimate_method: str, optional
+    :param quantile_duration: The duration of the quantile (hour), defaults to 1
+    :type quantile_duration: int | float, optional
+    :param chunk_size: the size of the chunks in days, defaults to 365
+    :type chunk_size: int, optional
+    :param compute_uncertainties: Compute the uncertainties usung the parametric bootstrap method
+    :type compute_uncertainties: bool, True
+    :param bootstrap_sample: the size of bootstrap sample, default is 100
+    :type bootstrap_sample: int, optional
+    :return: A dictionary containing the results od the quantile computation:
+     Results include the quantile, the empirical return period,
+     the maxima for each chunk of chunk_size, the fit parameters of the `fit` extrem law.
+    :rtype: dict
+
+    """
+    # # R workaround as normal number (int) are passed to float to python
+    # t_axis = int(t_axis)
+    # chunk_size = int(chunk_size)
+
+    if pd.Timedelta(
+        hours=quantile_duration,
+    ) < pd.Timedelta(
+        seconds=model_time_step,
+    ):
+        raise ValueError(
+            "The quantile duration {quantile_duration} (hours) must be"
+            "greater or equal than the model time step {model_time_step} (seconds)"
+        )
+
+    if pd.Timedelta(
+        hours=quantile_duration,
+    ) > pd.Timedelta(
+        days=chunk_size,
+    ):
+        raise ValueError(
+            "The chunk_size {chunk_size} (days) must be"
+            " greater or equal than the quantile duration {quantile_duration} (hours)"
+        )
+
+    if array is None:
+        raise ValueError("Input array is None, no data to compute quantile.")
+
+    if maxima is None:
+        array = time_resample_array(
+            array=array,
+            quantile_duration=quantile_duration,
+            model_time_step=model_time_step,
+            quantile_chunk_size=chunk_size,
+            t_axis=t_axis,
+        )
+
+        maxima = compute_maxima(
+            array=array,
+            t_axis=t_axis,
+            nb_minimum_chunks=nb_minimum_chunks,
+            chunk_size=chunk_size,
+            quantile_duration=quantile_duration,
+        )
+
+    results = fit_quantile_unparallel(
+        maxima=maxima,
+        t_axis=t_axis,
+        return_periods=return_periods,
+        fit=fit,
+        estimate_method=estimate_method,
+        quantile_duration=quantile_duration,
+        chunk_size=chunk_size,
+    )
+
+    if compute_uncertainties:
+        # calcul des incertitudes méthode bootstrap
+        parametric_bootstrap_uncertainties_unparallel(
+            q_results=results,
+            bootstrap_sample=bootstrap_sample,
+            return_periods=return_periods,
+            estimate_method=estimate_method,
+        )
+
+    return results