smashbox 1.0__py2.py3-none-any.whl

smashbox/stats/mystats.py

@@ -0,0 +1,1632 @@
+from smashbox.stats import stats
+from smashbox.tools import tools
+import numpy as np
+import multiprocessing
+import os
+from functools import partial
+from tqdm import tqdm
+import pandas as pd
+from smash.fcore import _mwd_metrics as smash_metrics
+
+
+class mystats:
+    """
+    The class mystats includes functions and children classes to compute basics statistics
+    with the results of the smash model.
+    """
+
+    def __init__(self, parent_class):
+        self._parent_class = parent_class
+        """_parent_class attribute stores the parent_class src.model() to be able to
+        access to the result of the smash simulation"""
+
+        self.misfit_stats = misfit_stats(self)
+        """Attribute misfit_stats stores the class src.mystats.misfit_stats(). Its goal
+         is to compute misfit criteria between simulated and observed discharges"""
+        self.quantile_stats = spatial_quantile()
+        """Attribute quantile_stats owns the class src.mystats.spatial_quantile().
+         Its goal is to compute the discharges quantiles for various return period."""
+        self.spatial_stats = spatial_stats(self)
+        """Atrribute spatial_stats owns the class src.mystats.spatial_stats(). Its goal
+        is to provide basic statistics on the discharges field over the time
+        (mean, median, q20, q80, maximum, minimum)"""
+        self.outlets_stats = outlets_stats(self)
+        """Atrribute outlets_stats owns the class src.mystats.outlets_stats().
+        Its goal is to provide basic statistics on the discharges at every outlets over the
+        time (mean, median, q20, q80, maximum, minimum)"""
+
+    def fmisfit_stats(self, nodata=-99.0, column=[], ret=False, use_smash_metrics=True):
+        """
+        Compute the misfit for every outlets between the simulated and the
+         observed discharges
+        :param nodata: No data values, defaults to -99.0
+        :type nodata: TYPE, optional
+        :param column: column on which to compute the statistics (gauge), defaults to []
+        :type column: TYPE, optional
+        :param ret: return the result, defaults to False
+        :type ret: TYPE, optional
+        :return: object with attributes with different statistics.
+        :rtype: class src.mystats.misfit.results()
+
+        """
+
+        if not use_smash_metrics:
+            self.misfit_stats.se(nodata=nodata, column=column)
+            self.misfit_stats.mse(nodata=nodata, column=column)
+            self.misfit_stats.rmse(nodata=nodata, column=column)
+            self.misfit_stats.nrmse(nodata=nodata, column=column)
+            self.misfit_stats.mae(nodata=nodata, column=column)
+            self.misfit_stats.mape(nodata=nodata, column=column)
+            self.misfit_stats.lgrm(nodata=nodata, column=column)
+            self.misfit_stats.nse(nodata=nodata, column=column)
+            self.misfit_stats.nnse(nodata=nodata, column=column)
+            self.misfit_stats.kge(nodata=nodata, column=column)
+        else:
+            self.misfit_stats.sm_se(column=column)
+            self.misfit_stats.sm_mse(column=column)
+            self.misfit_stats.sm_rmse(column=column)
+            self.misfit_stats.sm_nrmse(column=column)
+            self.misfit_stats.sm_mae(column=column)
+            self.misfit_stats.sm_mape(column=column)
+            self.misfit_stats.sm_lgrm(column=column)
+            self.misfit_stats.sm_nse(column=column)
+            self.misfit_stats.sm_nnse(column=column)
+            self.misfit_stats.sm_kge(column=column)
+
+        if ret:
+            return self.misfit.results
+
+    def fspatial_stats(self, ret=False):
+        """
+        Compute basics statistics over the time (mean, median, q20, q80, maximum, minimum)
+         on the spatial discharges field.
+        :param ret: return the result, defaults to False
+        :type ret: TYPE, optional
+        :return: object with attributes with different statistics.
+        :rtype: class src.mystats.spatial_stats.results()
+
+        """
+
+        if not hasattr(self._parent_class.extra_smash_results, "q_domain"):
+            raise ValueError(
+                "No smash extra results  'q_domain' found. Run forward_run()"
+                "with return_options={'q_domain': True}"
+            )
+
+        self.spatial_stats.mean()
+        self.spatial_stats.median()
+        self.spatial_stats.q20()
+        self.spatial_stats.q80()
+        self.spatial_stats.maximum()
+        self.spatial_stats.minimum()
+        self.spatial_stats.var()
+
+        if ret:
+            return self.spatial_stats.results
+
+    def foutlets_stats(self, ret=False):
+        """
+        Compute basices statistics over the time (mean, median, q20, q80, maximum, minimum)
+         at every outlets.
+        :param ret: return the result, defaults to False
+        :type ret: TYPE, optional
+        :return: object with attributes with different statistics.
+        :rtype: class src.mystats.outlets_stats.results()
+
+        """
+        if self._parent_class.mysmashmodel is None:
+            raise ValueError(
+                "Attribut mysmashmodel is None. Perhaps, you forget to buil and run the"
+                "smash model..."
+            )
+
+        self.outlets_stats.mean()
+        self.outlets_stats.median()
+        self.outlets_stats.q20()
+        self.outlets_stats.q80()
+        self.outlets_stats.maximum()
+        self.outlets_stats.minimum()
+        self.outlets_stats.var()
+
+        if ret:
+            return self.outlets_stats.results
+
+    @tools.autocast_args
+    def fmaxima_stats(
+        self,
+        t_axis: int = 2,
+        nb_minimum_chunks: int = 4,
+        chunk_size: int = 365,
+        quantile_duration: list | tuple = [1, 2, 3, 4, 6, 12, 24, 48, 72],
+        cumulated_maxima: bool = True,
+    ):
+        """
+        Compute the maximum discharge values of a 3D array by chunk, corresponding to `chunk_size` (days), along axis `t_axis` (time) for each pixel of the array.(nbX, nbY).
+
+        Parameters
+        ----------
+
+        t_axis : int
+            The axis along with the maximum will be computed. This axis should correspond
+            to the time.
+        nb_minimum_chunks: int
+            number of minimum chunks required to compute the maxima along
+        the t_axis. Default is set to 4. If the number of chunks is lower, the function
+        will return None.
+        chunk_size: int
+            Size of the chunks in days. Default is 365 days.
+        quantile_duration: list | tuple
+            The duration of every quantile (hours). The discharges will be resampled for every duration. Default is [1, 2, 3, 4, 6, 12, 24, 48, 72] hours.
+        cumulated_maxima: bool
+            For each call of the function, the maxima will accumulate in a matrix for
+            each quantil duration. This provide a convient way to compute the quantile
+            (fit gumbel/gev) after many successive simulations.
+
+
+        Examples
+        --------
+        >>> import smashbox
+        >>> import numpy as np
+        >>>
+        >>> graffas_prcp = np.zeros(shape=(142, 166, 1300))
+        >>> rng = np.random.default_rng()
+        >>> graffas_prcp = (
+        >>>     graffas_prcp
+        >>>     + rng.multinomial(20, [0.2, 0.8], size=graffas_prcp.shape)[:, :, :, 0]
+        >>> )
+        >>>
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("graffas_zone")
+        >>> sb.graffas_zone.generate_mesh()
+        >>> sb.graffas_zone.atmos_data_connector(input_prcp=graffas_prcp)
+        >>> sb.graffas_zone.model()
+        >>> sb.graffas_zone.forward_run(invert_states=True, return_options={"q_domain": True})
+        >>>
+        >>> sb.graffas_zone.mystats.stats_maxima(chunk_size=10)
+        >>> sb.graffas_zone.mystats.stats_maxima(chunk_size=10)
+        >>>
+        >>> results = stats.fit_quantile(
+        >>>    maxima=es.graffas_zone.mystats.spatial_quantile.spatial_cumulated_maxima[
+        >>>        :, :, :, 0
+        >>>    ],
+        >>>    t_axis=2,
+        >>>    return_periods=[2, 5, 10, 20, 50, 100],
+        >>>    fit="gumbel",
+        >>>    estimate_method="MLE",
+        >>>    quantile_duration=1,
+        >>>    ncpu=6,
+        >>>)
+
+        """
+        if pd.Timedelta(
+            hours=max(quantile_duration),
+        ) > pd.Timedelta(
+            days=chunk_size,
+        ):
+            raise ValueError(
+                f"The chunk_size {chunk_size} (days) must be"
+                f" greater or equal than the quantile duration {max(quantile_duration)} (hours)"
+            )
+
+        if not hasattr(self._parent_class.extra_smash_results, "q_domain"):
+            raise ValueError(
+                "No smash extra results  'q_domain' found. Run forward_run()"
+                "with return_options={'q_domain': True}"
+            )
+
+        all_maxima = None
+        for id_dur, duration in enumerate(quantile_duration):
+            array = stats.time_resample_array(
+                array=self._parent_class.extra_smash_results.q_domain,
+                quantile_duration=duration,
+                model_time_step=self._parent_class.mysmashmodel.setup.dt,
+                quantile_chunk_size=chunk_size,
+                t_axis=t_axis,
+            )
+
+            maxima = stats.compute_maxima(
+                array=array,
+                t_axis=t_axis,
+                nb_minimum_chunks=nb_minimum_chunks,
+                chunk_size=chunk_size,
+                quantile_duration=duration,
+            )
+
+            if all_maxima is None:
+                all_maxima = (
+                    np.zeros(shape=(*maxima.shape, len(quantile_duration))) + np.nan
+                )
+                all_maxima_outlets = (
+                    np.zeros(
+                        shape=(
+                            len(self._parent_class.mysmashmodel.mesh.code),
+                            maxima.shape[t_axis],
+                            len(quantile_duration),
+                        )
+                    )
+                    + np.nan
+                )
+
+            all_maxima[:, :, :, id_dur] = maxima
+
+            for i in range(len(self._parent_class.mymesh.mesh["code"])):
+                coords = self._parent_class.mysmashmodel.mesh.gauge_pos[i]
+                all_maxima_outlets[i, :, id_dur] = all_maxima[
+                    coords[0], coords[1], :, id_dur
+                ]
+
+        if cumulated_maxima:
+            # if hasattr(self.quantile_stats, "spatial_cumulated_maxima"):
+            #     self.quantile_stats.spatial_cumulated_maxima = np.concat(
+            #         (self.quantile_stats.spatial_cumulated_maxima, all_maxima),
+            #         axis=t_axis,
+            #     )
+            #     self.quantile_stats.spatial_cumulated_maxima_outlets = np.concat(
+            #         (
+            #             self.quantile_stats.spatial_cumulated_maxima_outlets,
+            #             all_maxima_outlets,
+            #         ),
+            #         axis=1,
+            #     )
+            # else:
+            #     setattr(self.quantile_stats, "spatial_cumulated_maxima", all_maxima)
+            #     setattr(
+            #         self.quantile_stats,
+            #         "spatial_cumulated_maxima_outlets",
+            #         all_maxima_outlets,
+            #     )
+
+            if self.quantile_stats.spatial_cumulated_maxima is None:
+                self.quantile_stats.spatial_cumulated_maxima = all_maxima
+                self.quantile_stats.spatial_cumulated_maxima_outlets = all_maxima_outlets
+            else:
+                self.quantile_stats.spatial_cumulated_maxima = np.concat(
+                    (self.quantile_stats.spatial_cumulated_maxima, all_maxima),
+                    axis=t_axis,
+                )
+                self.quantile_stats.spatial_cumulated_maxima_outlets = np.concat(
+                    (
+                        self.quantile_stats.spatial_cumulated_maxima_outlets,
+                        all_maxima_outlets,
+                    ),
+                    axis=1,
+                )
+
+        # setattr(self.quantile_stats, "spatial_maxima", all_maxima)
+        # setattr(self.quantile_stats, "spatial_maxima_outlets", all_maxima_outlets)
+        self.quantile_stats.spatial_maxima = all_maxima
+        self.quantile_stats.spatial_maxima_outlets = all_maxima_outlets
+
+    @tools.autocast_args
+    def fquantile_stats2(
+        self,
+        t_axis: int = 2,
+        return_periods: list | tuple = [2, 5, 10, 20, 50, 100],
+        fit: str = "gumbel",
+        nb_minimum_chunks: int = 4,
+        quantile_duration: list | tuple = [1, 2, 3, 4, 6, 12, 24, 48, 72],
+        estimate_method: str = "MLE",
+        chunk_size: int = 365,
+        ncpu: int | None = None,
+        # from_maxima: bool = False,
+        compute_uncertainties: bool = False,
+        bootstrap_sample: int = 100,
+    ):
+        """
+        Compute the discharge quantile of an 3D array by chunk, corresponding to
+         `chunk_size` (days), along axis `t_axis` (time) for each pixel of the array.
+         (nbX, nbY), for each duration `quantile_duration` and for each return period
+         `return_period`. This function perform the computation in parallel respect
+         to the the list of quantile duration.
+
+        Parameters
+        ----------
+
+        t_axis : int
+            The axis along with the maximum will be computed. This axis should correspond
+            to the time.
+        return_periods: list | tuple
+            The duration of every return period of unit `chunk_size`.
+            Default is [2, 5, 10, 20, 50, 100] with a chunk_size=365 days.
+        fit: str
+            The extrem law to use to compute the quantile. Choice are
+            'gumbel' | 'gev'. Default is 'gumbel'.
+        nb_minimum_chunks: int
+            number of minimum chunks required to compute the maxima along
+        the t_axis. Default is set to 4. If the number of chunks is lower, the function
+        will return None.
+        estimate_method: str
+            The method to use to fit rhe Gumbel or GEV law. Choice are `MLE`
+            (Maximum Likelihood Estimate) or `MM` (Method of Moments). Default is `MLE`.
+        chunk_size: int
+            Size of the chunks in days. Default is 365 days.
+        quantile_duration: list | tuple
+            The duration of every quantile (hours). The discharges will be resampled for
+            every duration. Default is [1, 2, 3, 4, 6, 12, 24, 48, 72] hours.
+        ncpu: int
+            Number of cpu to use to parrallelize the computation. Default is set to
+            int(os.cpu_count() / 2).
+        compute_uncertainties: bool
+            Compute the uncertainties using the parametric bootstrap method
+        bootstrap_sample: int
+            Number of sample using by the bootstrap method, default is 100
+
+        Return:
+        ------
+        Results are stored in the class spatial_quantile wit different attributes:
+            - spatial_quantile_matrix : matrix of the spatial quantile for each duration
+            and each return period.
+            - spatial_maxima_matrix : matrix of the spatial maxima for each duration and
+            each return period.
+            - spatial_cumulated_maxima_matrix : matrix of the spatial accumulated maxima
+            for each duration and each return period.
+            - Quantile_{`duration`}h : class of spatial_quantile_results() with attributes:
+                - self.T : the return periods
+                - self.Q_th : the quantile matrix for every return periods
+                - self.T_emp : the empirical return period for each maximum
+                - self.maxima : the matrix of the maxima
+                - self.nb_chunks : nb of chunk, i.e data for each pixel
+                - self.fit : fitting law
+                - self.fit_shape : matrix of the shape coefficient
+                - self.fit_scale : matrix of the scale coefficient
+                - self.fit_loc : matrix of the localisation coefficient
+                - self.duration : duration of the quantile
+
+        Examples
+        --------
+        >>> import smashbox
+        >>> import numpy as np
+        >>>
+        >>> graffas_prcp = np.zeros(shape=(142, 166, 1300))
+        >>> rng = np.random.default_rng()
+        >>> graffas_prcp = (
+        >>>     graffas_prcp
+        >>>     + rng.multinomial(20, [0.2, 0.8], size=graffas_prcp.shape)[:, :, :, 0]
+        >>> )
+        >>>
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("graffas_zone")
+        >>> sb.graffas_zone.generate_mesh()
+        >>> sb.graffas_zone.atmos_data_connector(input_prcp=graffas_prcp)
+        >>> sb.graffas_zone.model()
+        >>> sb.graffas_zone.forward_run(invert_states=True, return_options={"q_domain": True})
+        >>>
+        >>> sb.graffas_zone.mystats.stats_quantile(chunk_size=10, ncpu=6)
+
+        """
+
+        if pd.Timedelta(
+            hours=max(quantile_duration),
+        ) > pd.Timedelta(
+            days=chunk_size,
+        ):
+            raise ValueError(
+                f"The chunk_size {chunk_size} (days) must be"
+                f"greater or equal than the quantile duration {max(quantile_duration)} (hours)"
+            )
+
+        if not hasattr(self._parent_class.extra_smash_results, "q_domain"):
+            raise ValueError(
+                "No smash extra results  'q_domain' found. Run forward_run()"
+                "with return_options={'q_domain': True}"
+            )
+
+        if ncpu is None:
+            ncpu = int(os.cpu_count() / 2)
+        else:
+            ncpu = int(min(ncpu, os.cpu_count() - 1))
+
+        model_time_step = self._parent_class.mysmashmodel.setup.dt
+
+        shape = list(self._parent_class.extra_smash_results.q_domain.shape)
+        shape.insert(0, shape.pop(t_axis))
+
+        spatial_quantile_matrix = np.zeros(
+            shape=(
+                shape[1],
+                shape[2],
+                len(quantile_duration),
+                len(return_periods),
+            )
+        )
+
+        spatial_quantile_matrix_outlets = np.zeros(
+            shape=(
+                len(self._parent_class.mysmashmodel.mesh.code),
+                len(quantile_duration),
+                len(return_periods),
+            )
+        )
+
+        spatial_maxima = None
+        spatial_maxima_outlets = None
+
+        q_domain = self._parent_class.extra_smash_results.q_domain
+
+        partial_sp_quantile = partial(
+            stats.spatial_quantiles_unparallel,
+            q_domain,
+            t_axis,
+            return_periods,
+            fit,
+            nb_minimum_chunks,
+            model_time_step,
+            estimate_method,
+            chunk_size,
+            compute_uncertainties,
+            bootstrap_sample,
+        )
+
+        if hasattr(self.quantile_stats, "spatial_cumulated_maxima"):
+            imap_args = []
+            for id_dur, duration in enumerate(quantile_duration):
+                imap_args.append(
+                    [
+                        duration,
+                        self.quantile_stats.spatial_cumulated_maxima[:, :, :, id_dur],
+                    ]
+                )
+        else:
+            imap_args = [[duration] for id_dur, duration in enumerate(quantile_duration)]
+
+        with multiprocessing.Pool(ncpu) as p, tqdm(total=len(quantile_duration)) as pbar:
+
+            for res in p.starmap(
+                partial_sp_quantile,
+                imap_args,
+                chunksize=1,
+            ):
+                pbar.update()
+                pbar.refresh()
+                pos = quantile_duration.index(res["duration"])
+                spatial_quantile_matrix[:, :, pos, :] = res["Q_th"]
+
+                for i in range(len(self._parent_class.mymesh.mesh["code"])):
+                    coords = self._parent_class.mysmashmodel.mesh.gauge_pos[i]
+                    spatial_quantile_matrix_outlets[i, pos, :] = spatial_quantile_matrix[
+                        coords[0], coords[1], pos, :
+                    ]
+
+                if spatial_maxima is None:
+                    spatial_maxima = (
+                        np.zeros(shape=(*res["maxima"].shape, len(quantile_duration)))
+                        + np.nan
+                    )
+                    spatial_maxima_outlets = (
+                        np.zeros(
+                            shape=(
+                                len(self._parent_class.mysmashmodel.mesh.code),
+                                spatial_quantile["maxima"].shape[t_axis],
+                                len(quantile_duration),
+                            )
+                        )
+                        + np.nan
+                    )
+
+                spatial_maxima[:, :, :, pos] = res["maxima"]
+
+                for i in range(len(self._parent_class.mymesh.mesh["code"])):
+                    coords = self._parent_class.mysmashmodel.mesh.gauge_pos[i]
+                    spatial_maxima_outlets[i, :, pos] = spatial_maxima[
+                        coords[0], coords[1], :, pos
+                    ]
+
+                if not hasattr(self.quantile_stats, f"Quantile_{res['duration']}h"):
+                    setattr(
+                        self.quantile_stats,
+                        f"Quantile_{res['duration']}h",
+                        spatial_quantile_results(),
+                    )
+
+                eval(
+                    f"self.quantile_stats.Quantile_{res['duration']}h."
+                    f"fill_attribute(res)"
+                )
+
+                # setattr(self.quantile_stats, "spatial_quantile", spatial_quantile_matrix)
+                self.quantile_stats.spatial_quantile = spatial_quantile_matrix
+                self.quantile_stats.spatial_quantile_outlets = (
+                    spatial_quantile_matrix_outlets
+                )
+
+                # if not from_maxima:
+                # setattr(self.quantile_stats, "spatial_maxima", spatial_maxima)
+                self.quantile_stats.spatial_maxima = spatial_maxima
+                self.quantile_stats.spatial_maxima_outlets = spatial_maxima_outlets
+
+    @tools.autocast_args
+    def fquantile_stats(
+        self,
+        t_axis: int = 2,
+        return_periods: list | tuple = [2, 5, 10, 20, 50, 100],
+        fit: str = "gumbel",
+        nb_minimum_chunks: int = 4,
+        quantile_duration: list | tuple = [1, 2, 3, 4, 6, 12, 24, 48, 72],
+        estimate_method: str = "MLE",
+        chunk_size: int = 365,
+        ncpu: int | None = None,
+        # from_maxima: bool = False,
+        compute_uncertainties: bool = False,
+        bootstrap_sample: int = 100,
+    ):
+        """
+        Compute the discharge quantile of an 3D array by chunk, corresponding to
+        `chunk_size` (days), along axis `t_axis` (time) for each pixel of the array
+        (nbX, nbY), for each duration `quantile_duration` and for each return period
+        `return_period`.
+        This function fit the coefficient of the extrem law in parallel along the Y axis
+        of the input maxima array (shape=(nbX,nbY,nbchunks)).
+
+        Parameters
+        ----------
+
+        t_axis : int
+            The axis along with the maximum will be computed. This axis should correspond
+            to the time.
+        return_periods: list | tuple
+            The duration of every return period of unit `chunk_size`.
+            Default is [2, 5, 10, 20, 50, 100] with a chunk_size=365 days.
+        fit: str
+            The extrem law to use to compute the quantile. Choice are
+            'gumbel' | 'gev'. Default is 'gumbel'.
+        nb_minimum_chunks: int
+            number of minimum chunks required to compute the maxima along
+        the t_axis. Default is set to 4. If the number of chunks is lower, the function
+        will return None.
+        estimate_method: str
+            The method to use to fit rhe Gumbel or GEV law. Choice are `MLE`
+            (Maximum Likelihood Estimate) or `MM` (Method of Moments). Default is `MLE`.
+        chunk_size: int
+            Size of the chunks in days. Default is 365 days.
+        quantile_duration: list | tuple
+            The duration of every quantile (hours). The discharges will be resampled for
+            every duration. Default is [1, 2, 3, 4, 6, 12, 24, 48, 72] hours.
+        ncpu: int
+            Number of cpu to use to parrallelize the computation. Default is set to
+            int(os.cpu_count() / 2).
+        compute_uncertainties: bool
+            Compute the uncertainties using the parametric bootstrap method
+        bootstrap_sample: int
+            Number of sample using by the bootstrap method, default is 100
+
+        Return:
+        ------
+        Results are stored in the class spatial_quantile wit different attributes:
+            - spatial_quantile_matrix : matrix of the spatial quantile for each duration
+            and each return period.
+            - spatial_maxima_matrix : matrix of the spatial maxima for each duration and
+            each return period.
+            - spatial_cumulated_maxima_matrix : matrix of the spatial accumulated maxima
+            for each duration and each return period.
+            - Quantile_{`duration`}h : class of spatial_quantile_results() with attributes:
+                - self.T : the return periods
+                - self.Q_th : the quantile matrix for every return periods
+                - self.T_emp : the empirical return period for each maximum
+                - self.maxima : the matrix of the maxima
+                - self.nb_chunks : nb of chunk, i.e data for each pixel
+                - self.fit : fitting law
+                - self.fit_shape : matrix of the shape coefficient
+                - self.fit_scale : matrix of the scale coefficient
+                - self.fit_loc : matrix of the localisation coefficient
+                - self.duration : duration of the quantile
+
+        Examples
+        --------
+        >>> import smashbox
+        >>> import numpy as np
+        >>>
+        >>> graffas_prcp = np.zeros(shape=(142, 166, 1300))
+        >>> rng = np.random.default_rng()
+        >>> graffas_prcp = (
+        >>>     graffas_prcp
+        >>>     + rng.multinomial(20, [0.2, 0.8], size=graffas_prcp.shape)[:, :, :, 0]
+        >>> )
+        >>>
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("graffas_zone")
+        >>> sb.graffas_zone.generate_mesh()
+        >>> sb.graffas_zone.atmos_data_connector(input_prcp=graffas_prcp)
+        >>> sb.graffas_zone.model()
+        >>> sb.graffas_zone.forward_run(invert_states=True, return_options={"q_domain": True})
+        >>>
+        >>> sb.graffas_zone.mystats.stats_quantile(chunk_size=10, ncpu=6)
+
+        """
+
+        if pd.Timedelta(
+            hours=max(quantile_duration),
+        ) > pd.Timedelta(
+            days=chunk_size,
+        ):
+            raise ValueError(
+                f"The chunk_size {chunk_size} (days) must be"
+                f" greater or equal than the quantile duration {max(quantile_duration)} (hours)"
+            )
+
+        if not hasattr(self._parent_class.extra_smash_results, "q_domain"):
+            raise ValueError(
+                "No smash extra results  'q_domain' found. Run forward_run()"
+                "with return_options={'q_domain': True}"
+            )
+
+        model_time_step = self._parent_class.mysmashmodel.setup.dt
+
+        shape = list(self._parent_class.extra_smash_results.q_domain.shape)
+        shape.insert(0, shape.pop(t_axis))
+
+        spatial_quantile_matrix = np.zeros(
+            shape=(
+                shape[1],
+                shape[2],
+                len(quantile_duration),
+                len(return_periods),
+            )
+        )
+        spatial_quantile_matrix_outlets = np.zeros(
+            shape=(
+                len(self._parent_class.mysmashmodel.mesh.code),
+                len(quantile_duration),
+                len(return_periods),
+            )
+        )
+
+        spatial_maxima = None
+        spatial_maxima_outlets = None
+
+        for id_dur, duration in tqdm(enumerate(quantile_duration)):
+
+            print(f"</> Computing spatial quantile for duration {duration}h")
+
+            # if hasattr(self.quantile_stats, "spatial_cumulated_maxima"):
+            if self.quantile_stats.spatial_cumulated_maxima is not None:
+                maxima = self.quantile_stats.spatial_cumulated_maxima[:, :, :, id_dur]
+            else:
+                maxima = None
+
+            spatial_quantile = stats.spatial_quantiles(
+                array=self._parent_class.extra_smash_results.q_domain,
+                t_axis=t_axis,
+                return_periods=return_periods,
+                fit=fit,
+                nb_minimum_chunks=nb_minimum_chunks,
+                model_time_step=model_time_step,
+                quantile_duration=duration,
+                estimate_method=estimate_method,
+                chunk_size=chunk_size,
+                ncpu=ncpu,
+                compute_uncertainties=compute_uncertainties,
+                bootstrap_sample=bootstrap_sample,
+                maxima=maxima,
+            )
+            # else:
+            #     spatial_quantile = stats.spatial_quantiles(
+            #         array=self._parent_class.extra_smash_results.q_domain,
+            #         t_axis=t_axis,
+            #         return_periods=return_periods,
+            #         fit=fit,
+            #         nb_minimum_chunks=nb_minimum_chunks,
+            #         model_time_step=model_time_step,
+            #         quantile_duration=duration,
+            #         estimate_method=estimate_method,
+            #         chunk_size=chunk_size,
+            #         ncpu=ncpu,
+            #         compute_uncertainties=compute_uncertainties,
+            #         bootstrap_sample=bootstrap_sample,
+            #         maxima=None,
+            #     )
+
+            print("</>")
+
+            pos = quantile_duration.index(spatial_quantile["duration"])
+            spatial_quantile_matrix[:, :, pos, :] = spatial_quantile["Q_th"]
+
+            for i in range(len(self._parent_class.mymesh.mesh["code"])):
+                coords = self._parent_class.mysmashmodel.mesh.gauge_pos[i]
+                spatial_quantile_matrix_outlets[i, :, :] = spatial_quantile_matrix[
+                    coords[0], coords[1], :, :
+                ]
+
+            if spatial_maxima is None:
+                spatial_maxima = (
+                    np.zeros(
+                        shape=(
+                            *spatial_quantile["maxima"].shape,
+                            len(quantile_duration),
+                        )
+                    )
+                    + np.nan
+                )
+                spatial_maxima_outlets = (
+                    np.zeros(
+                        shape=(
+                            len(self._parent_class.mysmashmodel.mesh.code),
+                            spatial_quantile["maxima"].shape[t_axis],
+                            len(quantile_duration),
+                        )
+                    )
+                    + np.nan
+                )
+
+            spatial_maxima[:, :, :, pos] = spatial_quantile["maxima"]
+
+            for i in range(len(self._parent_class.mymesh.mesh["code"])):
+                coords = self._parent_class.mysmashmodel.mesh.gauge_pos[i]
+                spatial_maxima_outlets[i, :, id_dur] = spatial_maxima[
+                    coords[0], coords[1], :, id_dur
+                ]
+
+            if not hasattr(self.quantile_stats, f"Quantile_{duration}h"):
+                setattr(
+                    self.quantile_stats,
+                    f"Quantile_{duration}h",
+                    spatial_quantile_results(),
+                )
+
+            eval(
+                f"self.quantile_stats.Quantile_{duration}h."
+                f"fill_attribute(spatial_quantile)"
+            )
+
+        # setattr(self.quantile_stats, "spatial_quantile", spatial_quantile_matrix)
+        self.quantile_stats.spatial_quantile = spatial_quantile_matrix
+        self.quantile_stats.spatial_quantile_outlets = spatial_quantile_matrix_outlets
+
+        # if not from_maxima:
+        # setattr(self.quantile_stats, "spatial_maxima", spatial_maxima)
+        self.quantile_stats.spatial_maxima = spatial_maxima
+        self.quantile_stats.spatial_maxima_outlets = spatial_maxima_outlets
+
+
+class misfit_results:
+    """
+    The class misfit_results stores the results of the misfits criterium
+    """
+
+    def __init__(self):
+        self.mse = None
+        """MSE for each outlets of the Smash model.
+         mse = (1.0 / nb_valid_data)* np.sum((obs - sim) ** 2.0)
+        """
+        self.rmse = None
+        """RMSE for each outlets of the Smash model.
+         rmse = np.sqrt((1.0 / nb_valid_data)* np.sum((obs - sim) ** 2.0))
+        """
+        self.nrmse = None
+        """Normalized-RMSE for each outlets of the Smash model.
+         nrmse = res_rmse / mean_obs
+        """
+        self.se = None
+        """SE for each outlets of the Smash model. se =
+            np.sum((obs - sim) ** 2.0)
+        )"""
+        self.mae = None
+        """MAE for each outlets of the Smash model. 
+            mae = np.sqrt(np.sum(abs(obs - sim))
+        )"""
+        self.mape = None
+        """MAPE for each outlets of the Smash model. 
+            mape = np.sqrt(
+                np.sum(abs((obs - sim) / obs))
+            )
+        )"""
+        self.lgrm = None
+        """LGRM for each outlets of the Smash model. 
+            lgrm = np.sum(
+                obs * (np.log((obs / sim) ** 2.0)), axis=t_axis, where=mask_nodata
+            )
+        )"""
+        self.nse = None
+        """NSE for each outlets of the Smash model."""
+        self.nnse = None
+        """NNSE for each outlets of the Smash model. nnse = 1.0 / (2.0 - nse)"""
+        self.kge = None
+        """KGE for each outlets of the Smash model."""
+
+
+class spatial_stats_results:
+    """
+    The class spatial_stats_results stores the results of the spatial statistics
+    on discharges at every pixel.
+    """
+
+    def __init__(self):
+        self.min = None
+        """The minimum values for each pixel"""
+        self.max = None
+        """The maximum values for each pixel"""
+        self.mean = None
+        """The mean value for each pixel"""
+        self.median = None
+        """The median values for each pixel"""
+        self.q20 = None
+        """The percentile 20% for each pixel"""
+        self.q80 = None
+        """The percentile 80% for each pixel"""
+        self.var = None
+        """The variance for each pixel"""
+
+
+class outlets_stats_results:
+    """
+    The class outlets_stats_results stores the results of the statistics
+    on discharges at every outlets.
+    """
+
+    def __init__(self):
+        self.min = None
+        """The minimum values for each outlets"""
+        self.max = None
+        """The maximum values for each outlets"""
+        self.mean = None
+        """The mean values for each outlets"""
+        self.median = None
+        """The median values for each outlets"""
+        self.q20 = None
+        """The percentile 20%  values for each outlets"""
+        self.q80 = None
+        """The percentile 80%  values for each outlets"""
+        self.var = None
+        """The variance for each pixel"""
+
+
+class spatial_quantile_results:
+    """
+    The class spatial_quantile_results stores the results of the quantiles computed for
+     different return period. Results include the quantile, the empirical return period,
+     the maxima for each chunk of chunk_size, the fit parameters of the `fit` extrem law.
+    """
+
+    def __init__(self):
+        self.T = None
+        """The returns periods"""
+        self.Q_th = None
+        """The theorical discharge quantiles for each return period"""
+        self.T_emp = None
+        """The empirical return period for each maxima"""
+        self.maxima = None
+        """The maxima for each chunk of size chunk_size (default is annual)"""
+        self.nb_chunks = None
+        """The number of chunk (default is number of years)"""
+        self.fit = None
+        """The extrem law used to fit the maxima and the empirical quantile"""
+        self.fit_shape = None
+        """The shape coefficient of the extrem law"""
+        self.fit_scale = None
+        """The scale coefficient of the scale law"""
+        self.fit_loc = None
+        """The fit coefficient of the extream law"""
+        self.duration = None
+        """The duration of the quantile (hours)"""
+        self.chunk_size = None
+        """The size of the chunk on which the maxima are computed (unit of the return
+         period, default is 365 days (1 year))"""
+        self.Umin = None
+        """Uncertainties minimum values"""
+        self.Umax = None
+        """Uncertainties maximum values"""
+
+    def fill_attribute(self, stats_spatial_quantile: dict = None):
+        """
+        Fill the attribute of the class spatial_quantile_results.
+
+        :param stats_spatial_quantile: Dict of the spatial quantile results, defaults to None
+        :type stats_spatial_quantile: dict, optional
+
+        """
+
+        self.T = stats_spatial_quantile["T"]
+        self.Q_th = stats_spatial_quantile["Q_th"]
+        self.T_emp = stats_spatial_quantile["T_emp"]
+        self.maxima = stats_spatial_quantile["maxima"]
+        self.nb_chunks = stats_spatial_quantile["nb_chunks"]
+        self.fit = stats_spatial_quantile["fit"]
+        self.fit_shape = stats_spatial_quantile["fit_shape"]
+        self.fit_scale = stats_spatial_quantile["fit_scale"]
+        self.fit_loc = stats_spatial_quantile["fit_loc"]
+        self.duration = stats_spatial_quantile["duration"]
+        self.chunk_size = stats_spatial_quantile["chunk_size"]
+        if "Umin" in stats_spatial_quantile:
+            self.Umin = stats_spatial_quantile["Umin"]
+        if "Umax" in stats_spatial_quantile:
+            self.Umax = stats_spatial_quantile["Umax"]
+
+
+class spatial_quantile:
+    """Parent class spatial quantile. Class to store results of the spatial quantile."""
+
+    def __init__(self):
+        self.spatial_maxima = None
+        """Spatial matrix of the maximum discharges computed on period long of `chunk_size`. If chunk_size is 365, the matrix store the maximum annual discharges. Shape=(nbx, nby, nb_chunk, duration)"""
+        self.spatial_maxima_outlets = None
+        """Outlets matrix of the maximum discharges computed on period long of `chunk_size`. If chunk_size is 365, the matrix store the maximum annual discharges.Shape=(nb_gauge, nb_chunk, duration)"""
+        self.spatial_cumulated_maxima = None
+        """Spatial matrix of the maximum discharges computed on period long of `chunk_size` and accumulated over several simulation. If chunk_size is 365, the matrix store the maximum annual discharges. These maximal values are stacked to the matrix through every simulations.Shape=(nbx, nby, nb_chunk*nb_simulations, duration)"""
+        self.spatial_cumulated_maxima_outlets = None
+        """Outlets matrix of the maximum discharges computed on period long of `chunk_size`. If chunk_size is 365, the matrix store the maximum annual discharges. These maximal values are stacked to the matrix through every simulations.Shape=(nb_gauge, nb_chunk*nb_simulations, duration)"""
+        self.spatial_quantile = None
+        """Spatial matrix of the discharges quantile computed from the maximum discharges.Shape=(nbx, nby, duration, return_period)"""
+        self.spatial_quantile_outlets = None
+        """Outlets matrix of the discharges quantile computed from the maximum discharges.Shape=(nb_gauge, duration, return_period)"""
+        # pass
+
+
+class spatial_stats:
+    """Class for computing the spatial statistics on the discharges."""
+
+    def __init__(self, parent_class):
+        self._parent_class = parent_class
+        """The parent class in order to access to the results of the smash simulation"""
+        self.results = spatial_stats_results()
+        """The results of the spatial statistics"""
+
+    def mean(self):
+        """Compute the spatial mean of the discharges."""
+        self.results.mean = np.nanmean(
+            self._parent_class._parent_class.extra_smash_results.q_domain, axis=2
+        )
+
+    def minimum(self):
+        """Compute the spatial minimum of the discharges."""
+        self.results.min = np.nanmin(
+            self._parent_class._parent_class.extra_smash_results.q_domain, axis=2
+        )
+
+    def maximum(self):
+        """Compute the spatial maximum of the discharges."""
+        self.results.max = np.nanmax(
+            self._parent_class._parent_class.extra_smash_results.q_domain, axis=2
+        )
+
+    def median(self):
+        """Compute the spatial median of the discharges."""
+        self.results.median = np.quantile(
+            self._parent_class._parent_class.extra_smash_results.q_domain, 0.5, axis=2
+        )
+
+    def q20(self):
+        """Compute the spatial percentile 20% of the discharges."""
+        self.results.q20 = np.quantile(
+            self._parent_class._parent_class.extra_smash_results.q_domain, 0.2, axis=2
+        )
+
+    def q80(self):
+        """Compute the spatial percentile 80% of the discharges."""
+        self.results.q80 = np.quantile(
+            self._parent_class._parent_class.extra_smash_results.q_domain, 0.8, axis=2
+        )
+
+    def var(self):
+        """Compute the variance of the discharges for each pixel."""
+        self.results.var = np.var(
+            self._parent_class._parent_class.extra_smash_results.q_domain, axis=2
+        )
+
+
+class outlets_stats:
+    """Class for computing the statistics on the discharges at every outlets."""
+
+    def __init__(self, parent_class):
+        self._parent_class = parent_class
+        """The parent class in order to access to the results of the smash simulation"""
+        self.results_sim = outlets_stats_results()
+        """The results of the simulated dicharges statistics at every outlets"""
+        self.results_obs = outlets_stats_results()
+        """The results of the observed discharges statistics at every outlets"""
+
+    def mean(self):
+        """Compute the mean of the discharges at every outlets."""
+        qobs = self._parent_class._parent_class.mysmashmodel.response_data.q
+        qobs = np.where(qobs < 0, np.nan, qobs)
+
+        self.results_sim.mean = np.nanmean(
+            self._parent_class._parent_class.mysmashmodel.response.q, axis=1
+        )
+        self.results_obs.mean = np.nanmean(qobs, axis=1)
+
+    def minimum(self):
+        """Compute the minimum of the discharges at every outlets."""
+        qobs = self._parent_class._parent_class.mysmashmodel.response_data.q
+        qobs = np.where(qobs < 0, np.nan, qobs)
+
+        self.results_sim.min = np.nanmin(
+            self._parent_class._parent_class.mysmashmodel.response.q, axis=1
+        )
+        self.results_obs.min = np.nanmin(qobs, axis=1)
+
+    def maximum(self):
+        """Compute the maximum of the discharges at every outlets."""
+        qobs = self._parent_class._parent_class.mysmashmodel.response_data.q
+        qobs = np.where(qobs < 0, np.nan, qobs)
+
+        self.results_sim.max = np.nanmax(
+            self._parent_class._parent_class.mysmashmodel.response.q, axis=1
+        )
+        self.results_obs.max = np.nanmax(qobs, axis=1)
+
+    def median(self):
+        """Compute the median of the discharges at every outlets."""
+        qobs = self._parent_class._parent_class.mysmashmodel.response_data.q
+        qobs = np.where(qobs < 0, np.nan, qobs)
+
+        self.results_sim.median = np.nanquantile(
+            self._parent_class._parent_class.mysmashmodel.response.q, 0.5, axis=1
+        )
+        self.results_obs.median = np.nanquantile(qobs, 0.5, axis=1)
+
+    def q20(self):
+        """Compute the percentile 20% of the discharges at every outlets."""
+        qobs = self._parent_class._parent_class.mysmashmodel.response_data.q
+        qobs = np.where(qobs < 0, np.nan, qobs)
+
+        self.results_sim.q20 = np.nanquantile(
+            self._parent_class._parent_class.mysmashmodel.response.q, 0.2, axis=1
+        )
+        self.results_obs.q20 = np.nanquantile(qobs, 0.2, axis=1)
+
+    def q80(self):
+        """Compute the percentile 80% of the discharges at every outlets."""
+        qobs = self._parent_class._parent_class.mysmashmodel.response_data.q
+        qobs = np.where(qobs < 0, np.nan, qobs)
+
+        self.results_sim.q80 = np.nanquantile(
+            self._parent_class._parent_class.mysmashmodel.response.q, 0.8, axis=1
+        )
+        self.results_obs.q80 = np.nanquantile(qobs, 0.8, axis=1)
+
+    def var(self):
+        """Compute the variance of the discharges at every outlets"""
+        qobs = self._parent_class._parent_class.mysmashmodel.response_data.q
+        qobs = np.where(qobs < 0, np.nan, qobs)
+
+        self.results_sim.var = np.var(
+            self._parent_class._parent_class.extra_smash_results.q_domain, axis=1
+        )
+        self.results_obs.var = np.var(qobs, axis=1)
+
+
+class misfit_stats:
+    """Class for computing the misfit criterium on the discharges at every outlets."""
+
+    def __init__(self, parent_class):
+        self._parent_class = parent_class
+        """The parent class in order to access to the results of the smash simulation"""
+        self.results = misfit_results()
+        """The results of the misfit criterium at every outlets"""
+
+    def _update_column(self, column, outlets_name):
+        if len(outlets_name) > 0:
+            column = tools.array_isin(
+                self._parent_class._parent_class.mysmashmodel.mesh.code,
+                np.array(outlets_name),
+            )
+
+        if len(column) == 0:
+            column = list(
+                range(
+                    0,
+                    self._parent_class._parent_class.mysmashmodel.response.q.shape[0],
+                )
+            )
+
+        return column
+
+    def mse(self, nodata=-99.0, column: list = [], outlets_name: list = []):
+        """
+        Compute the mse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+
+        column = self._update_column(column, outlets_name)
+
+        self.results.mse = stats.mse(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_mse(self, column: list = [], outlets_name: list = []):
+        """
+        Compute the mse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+
+        column = self._update_column(column, outlets_name)
+
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            metric[i] = smash_metrics.mse(
+                qobs,
+                qsim,
+            )
+
+        self.results.mse = metric
+
+    def rmse(self, nodata=-99.0, column: list = [], outlets_name: list = []):
+        """
+        Compute the rmse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+
+        if len(outlets_name) > 0:
+            column = tools.array_isin(
+                self._parent_class._parent_class.mysmashmodel.mesh.code,
+                np.array(outlets_name),
+            )
+
+        if len(column) == 0:
+            column = list(
+                range(
+                    0, self._parent_class._parent_class.mysmashmodel.response.q.shape[0]
+                )
+            )
+
+        self.results.rmse = stats.rmse(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_rmse(self, column: list = [], outlets_name: list = []):
+        """
+        Compute the rmse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+
+        column = self._update_column(column, outlets_name)
+
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            metric[i] = smash_metrics.rmse(
+                qobs,
+                qsim,
+            )
+
+        self.results.rmse = metric
+
+    def nrmse(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the nrmse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+
+        if len(outlets_name) > 0:
+            column = tools.array_isin(
+                self._parent_class._parent_class.mysmashmodel.mesh.code,
+                np.array(outlets_name),
+            )
+
+        if len(column) == 0:
+            column = list(
+                range(
+                    0, self._parent_class._parent_class.mysmashmodel.response.q.shape[0]
+                )
+            )
+
+        self.results.nrmse = stats.nrmse(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_nrmse(self, column: list = [], outlets_name: list = []):
+        """
+        Compute the nrmse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+
+        column = self._update_column(column, outlets_name)
+
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            mean_qobs = np.mean(qobs)
+            metric[i] = smash_metrics.rmse(qobs, qsim) / mean_qobs
+
+        self.results.nrmse = metric
+
+    def se(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the se between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+
+        self.results.se = stats.se(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_se(self, column: list = [], outlets_name: list = []):
+        """
+        Compute the se between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            if not np.all(qobs < 0):
+                metric[i] = smash_metrics.se(
+                    qobs,
+                    qsim,
+                )
+
+        self.results.se = metric
+
+    def mae(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the mae between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+
+        self.results.mae = stats.mae(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_mae(self, column=[], outlets_name=[]):
+        """
+        Compute the mae between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            metric[i] = smash_metrics.mae(
+                qobs,
+                qsim,
+            )
+
+        self.results.mae = metric
+
+    def mape(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the mape between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+
+        self.results.mape = stats.mape(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_mape(self, column=[], outlets_name=[]):
+        """
+        Compute the mape between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            metric[i] = smash_metrics.mape(
+                qobs,
+                qsim,
+            )
+
+        self.results.mape = metric
+
+    def lgrm(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the lgrm between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+
+        self.results.lgrm = stats.lgrm(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_lgrm(self, column=[], outlets_name=[]):
+        """
+        Compute the lgrm between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            if not np.all(qobs < 0):
+                metric[i] = smash_metrics.lgrm(
+                    qobs,
+                    qsim,
+                )
+
+        self.results.lgrm = metric
+
+    def nse(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the nse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+
+        self.results.nse = stats.nse(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_nse(self, column=[], outlets_name=[]):
+        """
+        Compute the nse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            metric[i] = smash_metrics.nse(
+                qobs,
+                qsim,
+            )
+
+        self.results.nse = metric
+
+    def nnse(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the nnse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+
+        self.results.nnse = stats.nnse(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_nnse(self, column=[], outlets_name=[]):
+        """
+        Compute the nnse between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            metric[i] = smash_metrics.nnse(
+                qobs,
+                qsim,
+            )
+
+        self.results.nnse = metric
+
+    def kge(self, nodata=-99.0, column=[], outlets_name=[]):
+        """
+        Compute the kge between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+
+        self.results.kge = stats.kge(
+            self._parent_class._parent_class.mysmashmodel.response_data.q[column, :],
+            self._parent_class._parent_class.mysmashmodel.response.q[column, :],
+            nodata=-99.0,
+            t_axis=1,
+        )
+
+    def sm_kge(self, column=[], outlets_name=[]):
+        """
+        Compute the kge between the oberved and simulated discharges.
+        :param nodata: The no data value, defaults to -99.0
+        :type nodata: float, optional
+        :param column: the column nuber on which we want to compute the misfit,
+         defaults to []
+        :type column: list, optional
+        :param outlets_name: The names of the outlets for which we want to compute
+         the misfit, defaults to []
+        :type outlets_name: list, optional
+
+        """
+        column = self._update_column(column, outlets_name)
+        metric = np.zeros(shape=(len(column))) + np.nan
+
+        for i in range(len(column)):
+            qobs = self._parent_class._parent_class.mysmashmodel.response_data.q[i, :]
+            qsim = self._parent_class._parent_class.mysmashmodel.response.q[i, :]
+
+            metric[i] = smash_metrics.kge(
+                qobs,
+                qsim,
+            )
+
+        self.results.kge = metric