smashbox 1.0__py2.py3-none-any.whl

smashbox/plot/myplot.py

@@ -0,0 +1,1133 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import mpld3  # à ajouter dans le build du module
+
+from smashbox.tools import tools
+from smashbox.stats import stats
+from smashbox.plot import plot
+from smashbox.tools import geo_toolbox
+
+
+class myplot:
+    """Class that provide some plotting functions. Plot can be displayed with matplolib UI
+    or as html web page. Every plot can be saved into files."""
+
+    def __init__(self, parent_class):
+        """
+        Initialisation.
+        :param parent_class: The parent class src.model.model() to be able to access to
+         the smash model
+        :type parent_class: src.model.model()
+        """
+        self._parent_class = parent_class
+        """The parent class src.model.model() to be able to access to the smash model"""
+
+    def plot_mesh(
+        self,
+        coef_hydro: float = 99.0,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot the map of the mesh of the Smash model with teh outlets and the hydrographic
+        network.
+        :param coef_hydro: couloring cells where the surface is higher than `coef_hydro`%
+         of the total surface catchment, defaults to 99.0
+        :type coef_hydro: float, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+        default_ax_settings = plot.ax_properties(
+            title="Mesh of the Smash model",
+            xlabel="x_coords",
+            ylabel="y_coords",
+        )
+        default_ax_settings.update(**ax_settings)
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if not hasattr(self._parent_class.mymesh, "mesh"):
+            raise ValueError("No smash mesh found. Build the mesh first.")
+
+        fig, ax = plot.plot_mesh(
+            self._parent_class.mymesh.mesh,
+            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
+            coef_hydro=coef_hydro,
+            ax_settings=ax_settings,
+            fig_settings=fig_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+    def plot_catchment_surface_consistency(
+        self,
+        label: bool = True,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        plot_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot the modeled surface vs the observed surface. Check its consistency.
+         :param label, labels the point on the plot with the code of the outlets.
+         :type label: bool, default True
+        :param ax_settings, any properties of plot.ax_properties() class can be defined
+         in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class can be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param plot_settings,  any properties of plot.plot_properties() class can be
+        defined in this dictionnary, defaults to {}
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        default_ax_settings = plot.ax_properties(
+            title="Modeled and observed surface consistency",
+            xlabel="Observed surface",
+            ylabel="Modeled surface",
+        )
+        default_ax_settings.update(**ax_settings)
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if not hasattr(self._parent_class.mymesh, "mesh"):
+            raise ValueError("No smash mesh found. Build the mesh first.")
+
+        fig, ax = plot.plot_catchment_surface_consistency(
+            mesh=self._parent_class.mymesh.mesh,
+            label=label,
+            ax_settings=ax_settings,
+            fig_settings=fig_settings,
+            plot_settings=plot_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+    def plot_catchment_surface_error(
+        self,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot the modeled surface vs the observed surface. Check its consistency.
+         :param ax_settings, any properties of plot.ax_properties() class can be defined
+         in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class can be defined in this dictionnary, defaults to {}
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        default_ax_settings = plot.ax_properties(
+            title="Catchment surface error",
+            xlabel="Catchments",
+            ylabel="(Ssim - Sobs)/Sobs",
+        )
+        default_ax_settings.update(**ax_settings)
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if not hasattr(self._parent_class.mymesh, "mesh"):
+            raise ValueError("No smash mesh found. Build the mesh first.")
+
+        fig, ax = plot.plot_catchment_surface_error(
+            mesh=self._parent_class.mymesh.mesh,
+            ax_settings=ax_settings,
+            fig_settings=fig_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+    @tools.autocast_args
+    def plot_xy_quantile(
+        self,
+        duration: int = 1,
+        X: int = 0,
+        Y: int = 0,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        plot_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+
+        :param duration: Duration of the quantile, defaults to 1
+        :type duration: int, optional
+        :param X: X coordinate of the targeted cell (matrix coordinate system), defaults
+         to 0
+        :type X: int, optional
+        :param Y: Y coordinate of the targeted cell (matrix coordinate system), defaults
+        to 0
+        :type Y: int, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+        plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator,
+         defaults to False
+        :type html_show: bool, optional
+
+        """
+
+        if not hasattr(
+            self._parent_class.mystats.quantile_stats, f"Quantile_{duration}h"
+        ):
+            raise ValueError(f"No statistical results found for duration {duration}h")
+
+        results_quantile = getattr(
+            self._parent_class.mystats.quantile_stats,
+            f"Quantile_{duration}h",
+        )
+
+        if self._parent_class.mymesh.mesh["active_cell"][X, Y] == 0:
+            raise ValueError(
+                f"`{X},{Y}` coordinates does not correspond to an active cell."
+            )
+
+        default_ax_settings = plot.ax_properties(
+            title=f"Maximal discharges frequency curve on {results_quantile.chunk_size}"
+            " days",
+            xscale="log",
+            xlabel=f"Return period (*{results_quantile.chunk_size} days)",
+            ylabel="Discharges (m³/s)",
+            grid=True,
+            legend=True,
+        )
+        default_ax_settings.update(**ax_settings)
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        fig, ax = plot.plot_xy_quantile(
+            results_quantile.__dict__,
+            X,
+            Y,
+            ax_settings=default_ax_settings,
+            fig_settings=fig_settings,
+            plot_settings=plot_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+        # return fig, ax
+
+    @tools.autocast_args
+    def plot_outlets_quantile(
+        self,
+        duration: int = 1,
+        quantile_obs=True,
+        gauge: list | None = None,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        plot_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot the quantiles prediction for different return period for every outlets.
+        :param duration: Duration of the quantile, defaults to 1
+        :type duration: int, optional
+        :param quantile_obs: Compute and display the observed quantile in th graphics.
+        Observed quantile are computed again the whole observed discharge chronicle
+        from 1900 until today.
+        :type quantile_obs: Bool, default is True
+        :param gauge: List of gauge code to plot. Default is None. If None all gague
+        are plotted
+        :type gauge: list | None, default None.
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param plot_settings: Parameters of the matplotlib figure 'fig'. Any properties of
+         plot.plot_settings() class ca be defined in this dictionnary, defaults to {}
+        :type plot_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+        to False
+        :type html_show: bool, optional
+
+        """
+
+        # fig_settings = plot.fig_properties(**fig_settings)
+
+        if not hasattr(
+            self._parent_class.mystats.quantile_stats, f"Quantile_{duration}h"
+        ):
+            raise ValueError(f"No statistical results found for duration {duration}h")
+
+        gauge_pos = list(self._parent_class.mymesh.mesh["gauge_pos"])
+        gauge_code = list(self._parent_class.mymesh.mesh["code"])
+
+        if gauge is not None:
+            list_ind_gauge = []
+            for i, g in enumerate(gauge_code):
+                if g in gauge:
+                    list_ind_gauge.append(i)
+                else:
+                    print(f"</> gauge {g} not found in the mesh gauge list {gauge_code}")
+            if len(list_ind_gauge) > 0:
+                gauge_pos = gauge_pos[list_ind_gauge]
+                gauge_code = gauge_code[list_ind_gauge]
+            else:
+                print(f"</> gauge {gauge} not found in the mesh gauge list {gauge_code}")
+
+        yfig = int(np.sqrt(len(gauge_pos)))
+        xfig = int(np.ceil(len(gauge_pos) / yfig))
+
+        default_fig_settings = plot.fig_properties(ysize=yfig * 5, xsize=xfig * 3)
+        default_fig_settings.update(**fig_settings)
+
+        if quantile_obs:
+            res_quantile_obs = stats.quantil_obs(
+                qobs_directory=self._parent_class.mysetup.setup["qobs_directory"],
+                code=gauge_code,
+                model_time_step=self._parent_class.mysetup.setup["dt"],
+                quantile_duration=duration,
+            )
+        else:
+            res_quantile_obs = None
+
+        fig, axs = plt.subplots(
+            xfig,
+            yfig,
+            constrained_layout=True,
+        )
+
+        for ax, coords, code in zip(axs.flat, gauge_pos, gauge_code):
+
+            X, Y = coords
+            results_quantile = getattr(
+                self._parent_class.mystats.quantile_stats,
+                f"Quantile_{duration}h",
+            )
+
+            # default_ax_settings = plot.ax_properties(
+            #     title=f"Discharges quantile at gauge {code}",
+            #     legend_fontsize=6,
+            # )
+            # default_ax_settings.update(**ax_settings)
+
+            default_ax_settings = plot.ax_properties(
+                title=f"Discharges quantile at gauge {code}",
+                xscale="log",
+                xlabel=f"Return period (*{results_quantile.chunk_size} days)",
+                ylabel="Discharges (m³/s)",
+                grid=True,
+                legend=True,
+                legend_fontsize=8,
+                xtics_fontsize=8,
+                ytics_fontsize=8,
+            )
+            default_ax_settings.update(**ax_settings)
+
+            default_plot_settings = plot.plot_properties(
+                markersize=6,
+            )
+            default_plot_settings.update(**plot_settings)
+
+            fig, ax = plot.plot_xy_quantile(
+                results_quantile.__dict__,
+                X,
+                Y,
+                res_quantile_obs=res_quantile_obs,
+                gauge_pos=list(gauge_code).index(code),
+                figure=[fig, ax],
+                ax_settings=default_ax_settings,
+                plot_settings=default_plot_settings,
+            )
+
+        default_fig_settings.change((fig, axs))
+
+        if default_fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, axs
+
+    @tools.autocast_args
+    def plot_spatial_quantile(
+        self,
+        duration: int = 1,
+        T: int = 2,
+        vmin: float | None = 0,
+        vmax: float | None = None,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        html_show=False,
+    ):
+        """
+        Plot the map of the quantiles for given return period and a given duration.
+        :param duration: Duration of the quantile, defaults to 1
+        :type duration: int, optional
+        :param T: return period, defaults to 2 (default is years, but that depends
+         of the chunk size)
+        :type T: int, optional
+        :param vmin: Minimal bounds value for the colorbar, defaults to 0
+        :type vmin: float, optional
+        :param vmax: Maximal bounds value for the colorbar, defaults to None
+        :type vmax: float, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults to False
+        :type html_show: bool, optional
+
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if not hasattr(
+            self._parent_class.mystats.quantile_stats, f"Quantile_{duration}h"
+        ):
+            raise ValueError(f"No statistical results found for duration {duration}h")
+
+        results_quantile = getattr(
+            self._parent_class.mystats.quantile_stats,
+            f"Quantile_{duration}h",
+        )
+
+        default_ax_settings = plot.ax_properties(
+            title=f"Discharges quantile for duration={duration} h, T={T}",
+            xlabel="Coords X",
+            ylabel="Coords_Y",
+            clabel="Discharge (m^3/s)",
+            cmap="viridis",
+        )
+        default_ax_settings.update(**ax_settings)
+
+        z = list(results_quantile.T).index(T)
+
+        fig, ax = plot.plot_image(
+            matrice=results_quantile.Q_th[:, :, z],
+            bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
+            vmin=vmin,
+            vmax=vmax,
+            mask=self._parent_class.mysmashmodel.mesh.active_cell,
+            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
+            ax_settings=default_ax_settings,
+            fig_settings=fig_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, ax
+
+    @tools.autocast_args
+    def multiplot_spatial_quantile(
+        self,
+        duration: int = 1,
+        vmin: float | None = 0,
+        vmax: float | None = None,
+        ax_settings={},
+        fig_settings={},
+        html_show: bool = False,
+    ):
+        """
+        Plot the map of the quantiles for every return period for a given duration.
+        :param duration: Duration of the quantile, defaults to 1
+        :type duration: int, optional
+        :param vmin: Minimal bounds value for the colorbar, defaults to 0
+        :type vmin: float, optional
+        :param vmax: Maximal bounds value for the colorbar, defaults to None
+        :type vmax: float, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if not hasattr(
+            self._parent_class.mystats.quantile_stats, f"Quantile_{duration}h"
+        ):
+            raise ValueError(f"No statistical results found for duration {duration}h")
+
+        results_quantile = getattr(
+            self._parent_class.mystats.quantile_stats,
+            f"Quantile_{duration}h",
+        )
+
+        yfig = int(np.sqrt(len(results_quantile.T)))
+        xfig = int(np.ceil(len(results_quantile.T) / yfig))
+
+        fig, axs = plt.subplots(
+            xfig,
+            yfig,
+            constrained_layout=False,
+        )
+        plt.subplots_adjust(
+            left=None, bottom=None, right=None, top=None, wspace=0.5, hspace=None
+        )
+
+        for ax, T in zip(axs.flat, results_quantile.T):
+
+            default_ax_settings = plot.ax_properties(
+                title=f"Discharges quantile for duration={duration} h, T={T}",
+                xlabel="Coords X",
+                ylabel="Coords_Y",
+                clabel="Discharge (m^3/s)",
+                cmap="viridis",
+                title_fontsize=10,
+                label_fontsize=8,
+                xtics_fontsize=6,
+                ytics_fontsize=6,
+            )
+            default_ax_settings.update(**ax_settings)
+
+            z = list(results_quantile.T).index(T)
+
+            fig, ax = plot.plot_image(
+                matrice=results_quantile.Q_th[:, :, z],
+                bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
+                vmin=vmin,
+                vmax=vmax,
+                mask=self._parent_class.mysmashmodel.mesh.active_cell,
+                catchment_polygon=self._parent_class.mymesh.catchment_polygon,
+                ax_settings=default_ax_settings,
+                figure=[fig, ax],
+            )
+
+        [fig.delaxes(ax) for ax in axs.flatten() if not ax.has_data()]
+        fig_settings.change((fig, axs))
+
+        if fig_settings.figname is None or html_show:
+            if tools.with_reticulate():
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, axs
+
+    def plot_spatial_stats(
+        self,
+        stats: str = "max",
+        vmin: float | None = 0,
+        vmax: float | None = None,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot the map of a given spatial statistic.
+        :param stats: The statistic to plot, choice are
+         'max, min, mean, median, q20, q80', defaults to "max"
+        :type stats: str, optional
+        ::param vmin: Minimal bounds value for the colorbar, defaults to 0
+        :type vmin: float, optional
+        :param vmax: Maximal bounds value for the colorbar, defaults to None
+        :type vmax: float, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if not hasattr(self._parent_class.mystats.spatial_stats.results, stats):
+            raise ValueError(
+                f"Statistical results `{stats}` not found. Choice are: "
+                "[min, max, mean, median, q20, q80]"
+            )
+
+        stats_matrix = getattr(
+            self._parent_class.mystats.spatial_stats.results,
+            stats,
+        )
+        default_ax_settings = plot.ax_properties(
+            title="Maximal Discharges on periode"
+            f" {self._parent_class.mysmashmodel.setup.start_time} -"
+            f" {self._parent_class.mysmashmodel.setup.end_time}",
+            xlabel="Coords X",
+            ylabel="Coords_Y",
+            clabel="Discharge (m^3/s)",
+            cmap="viridis",
+        )
+        default_ax_settings.update(**ax_settings)
+
+        fig, ax = plot.plot_image(
+            matrice=stats_matrix,
+            bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
+            vmin=vmin,
+            vmax=vmax,
+            mask=self._parent_class.mysmashmodel.mesh.active_cell,
+            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
+            ax_settings=default_ax_settings,
+            fig_settings=fig_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, ax
+
+    def plot_hydrograph(
+        self,
+        columns: list | None = [],
+        outlets_name: list = [],
+        plot_rainfall: bool = True,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        plot_settings_sim: dict = {},
+        plot_settings_obs: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot the simulated and the observed hydrogram for different outlets.
+
+        :param columns: Columns of the matrix to plot (outlets), defaults to []
+        :type columns: list | None, optional
+        :param outlets_name: List of the outlets name to plot, defaults to []
+        :type outlets_name: list, optional
+        :param plot_rainfall: Plot the rainfall on the graphics, defaults to True
+        :type plot_rainfall: bool, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param plot_settings_sim: Parameters of the matplotlib curves. Any propoerties of
+         plot.plot_properties() class ca be defined in this dictionnary, defaults to {}
+        :type plot_settings_sim: dict, optional
+        :param plot_settings_obs: DParameters of the matplotlib curves. Any propoerties of
+         plot.plot_properties() class ca be defined in this dictionnary, defaults to {}
+        :type plot_settings_obs: dict, optional
+        :pparam html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if len(outlets_name) > 0:
+            columns = tools.array_isin(
+                self._parent_class.mysmashmodel.mesh.code,
+                np.array(outlets_name),
+            )
+
+        if columns is None:
+            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
+            outlets_name = list(self._parent_class.mysmashmodel.mesh.code)
+
+        if len(columns) == 0:
+            columns = [0]
+            outlets_name = [list(self._parent_class.mysmashmodel.mesh.code)[0]]
+
+        fig, ax = plot.plot_hydrograph(
+            model=self._parent_class.mysmashmodel,
+            columns=columns,
+            outlets_name=outlets_name,
+            plot_rainfall=plot_rainfall,
+            ax_settings=ax_settings,
+            fig_settings=fig_settings,
+            plot_settings_sim=plot_settings_sim,
+            plot_settings_obs=plot_settings_obs,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, ax
+
+    def plot_misfit(
+        self,
+        columns: list | None = None,
+        outlets_name: list = [],
+        misfit: str = "nse",
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot a misfit criteria for a given list of outlet.
+        :param columns: Columns of the matrix to plot (outlets), defaults to []
+        :type columns: list | None, optional
+        :param outlets_name: List of the outlets name to plot, defaults to []
+        :type outlets_name: list, optional
+        :param misfit: The misfit criteria to plot, choice are
+        "nse, nnse, rmse, nrmse, se, kge", defaults to "nse"
+        :type misfit: str, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        values = getattr(self._parent_class.mystats.misfit_stats.results, misfit)
+
+        if len(outlets_name) > 0:
+            columns = tools.array_isin(
+                self._parent_class.mysmashmodel.mesh.code,
+                np.array(outlets_name),
+            )
+
+        if columns is None:
+            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
+            outlets_name = self._parent_class.mysmashmodel.mesh.code
+
+        fig, ax = plot.plot_misfit(
+            values=values[columns],
+            names=outlets_name,
+            columns=None,
+            misfit=misfit,
+            ax_settings=ax_settings,
+            fig_settings=fig_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, ax
+
+    def plot_outlet_stats(
+        self,
+        columns: list | None = None,
+        outlets_name: list = [],
+        stat: str = "max",
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot a statistical criteria for a given list of outlet.
+        :param columns: Columns of the matrix to plot (outlets), defaults to []
+        :type columns: list | None, optional
+        :param outlets_name: List of the outlets name to plot, defaults to []
+        :type outlets_name: list, optional
+        :param misfit: The misfit criteria to plot, choice are
+        "nse, nnse, rmse, nrmse, se, kge", defaults to "nse"
+        :type misfit: str, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        values_sim = getattr(self._parent_class.mystats.outlets_stats.results_sim, stat)
+        values_obs = getattr(self._parent_class.mystats.outlets_stats.results_obs, stat)
+
+        if len(outlets_name) > 0:
+            columns = tools.array_isin(
+                self._parent_class.mysmashmodel.mesh.code,
+                np.array(outlets_name),
+            )
+
+        if columns is None:
+            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
+            outlets_name = list(self._parent_class.mysmashmodel.mesh.code)
+
+        fig, ax = plot.plot_outlet_stats(
+            values_sim=values_sim[columns],
+            values_obs=values_obs[columns],
+            names=outlets_name,
+            columns=None,
+            stat=stat,
+            ax_settings=ax_settings,
+            fig_settings=fig_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, ax
+
+    def multiplot_misfit(
+        self,
+        columns: list | None = None,
+        outlets_name: list = [],
+        misfit: list = [
+            "nse",
+            "nnse",
+            "kge",
+            "mse",
+            "rmse",
+            "nrmse",
+            "se",
+            "mae",
+            "mape",
+            "lgrm",
+        ],
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot misfit criterium for a given list of outlets.
+
+        :param columns: Columns of the matrix to plot (outlets), defaults to []
+        :type columns: list | None, optional
+        :param outlets_name: List of the outlets name to plot, defaults to []
+        :type outlets_name: list, optional
+        :param misfit: The misfit criteria to plot, list of criteria among
+        "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
+        :type misfit: str, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        if len(outlets_name) > 0:
+            columns = tools.array_isin(
+                self._parent_class.mysmashmodel.mesh.code,
+                np.array(outlets_name),
+            )
+
+        if columns is None:
+            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
+            outlets_name = list(self._parent_class.mysmashmodel.mesh.code)
+
+        yfig = int(np.sqrt(len(misfit)))
+        xfig = int(np.ceil(len(misfit) / yfig))
+
+        fig, axs = plt.subplots(
+            xfig,
+            yfig,
+            constrained_layout=True,
+        )
+
+        # for ax in axs:
+        #     ax.set_axis_off()
+
+        for ax, crit in zip(
+            axs.flat,
+            misfit,
+        ):
+
+            # ax.set_axis_on()
+            ax_settings["ylabel"] = f"{crit} criteria"
+            ax_settings["title"] = f"{crit} criteria"
+
+            if hasattr(self._parent_class.mystats.misfit_stats.results, crit):
+                values = getattr(self._parent_class.mystats.misfit_stats.results, crit)
+            else:
+                raise ValueError(
+                    f"`{crit}` is not a valid statistic. choice are:"
+                    "[nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge]"
+                )
+
+            fig, ax = plot.plot_misfit(
+                values=values[columns],
+                names=np.array(outlets_name),
+                columns=None,
+                misfit=crit,
+                figure=(fig, ax),
+                ax_settings=ax_settings,
+            )
+
+        [fig.delaxes(ax) for ax in axs.flatten() if not ax.has_data()]
+        fig_settings.change((fig, ax))
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, ax
+
+    def plot_misfit_map(
+        self,
+        misfit: str = "nse",
+        coef_hydro: float = 99.0,
+        ax_settings: dict = {},
+        fig_settings: dict = {},
+        plot_settings: dict = {},
+        html_show: bool = False,
+    ):
+        """
+        Plot a map of a misfit criteria.
+
+        :param columns: Columns of the matrix to plot (outlets), defaults to []
+        :type columns: list | None, optional
+        :param outlets_name: List of the outlets name to plot, defaults to []
+        :type outlets_name: list, optional
+        :param misfit: The misfit criteria to plot, choice are
+        "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
+        :type misfit: str, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        if hasattr(self._parent_class.mystats.misfit_stats.results, misfit):
+            values = getattr(self._parent_class.mystats.misfit_stats.results, misfit)
+        else:
+            raise ValueError(
+                f"`{misfit}` is not a valid statistic. choice are:"
+                "[nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge]"
+            )
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        name = self._parent_class.mysmashmodel.mesh.code
+        mesh = self._parent_class.mymesh.mesh
+
+        fig, ax = plot.plot_misfit_map(
+            values=values,
+            names=name,
+            mesh=mesh,
+            misfit=misfit,
+            coef_hydro=coef_hydro,
+            ax_settings=ax_settings,
+            fig_settings=fig_settings,
+            plot_settings=plot_settings,
+        )
+
+        if fig_settings.figname is None:
+            if tools.with_reticulate() or html_show:
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, ax
+
+    def multiplot_parameters(
+        self,
+        mask_active_cell=False,
+        ax_settings={},
+        fig_settings={},
+        html_show: bool = False,
+    ):
+        """
+        Multiplot map of every Smash parameters
+        :param mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
+        :type mask_active_cell: bool, False, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+
+        """
+
+        default_fig_settings = plot.fig_properties(xsize=8, ysize=8)
+        default_fig_settings.update(**fig_settings)
+
+        param = list(self._parent_class.mysmashmodel.rr_parameters.keys)
+
+        if mask_active_cell:
+            mask = self._parent_class.mysmashmodel.mesh.active_cell
+        else:
+            mask = None
+
+        yfig = int(np.sqrt(len(param)))
+        xfig = int(np.ceil(len(param) / yfig))
+
+        fig, axs = plt.subplots(
+            xfig,
+            yfig,
+            constrained_layout=False,
+        )
+        plt.subplots_adjust(
+            left=None, bottom=None, right=None, top=None, wspace=0.5, hspace=0.5
+        )
+        for ax, p in zip(axs.flat, param):
+
+            default_ax_settings = plot.ax_properties(
+                title=f"{p} parameters map",
+                xlabel="Coords X",
+                ylabel="Coords_Y",
+                clabel=f"{p} parameter value",
+                cmap="viridis",
+            )
+            default_ax_settings.update(**ax_settings)
+
+            z = param.index(p)
+
+            fig, ax = plot.plot_image(
+                matrice=self._parent_class.mysmashmodel.rr_parameters.values[:, :, z],
+                bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
+                mask=mask,
+                vmin=0.0,
+                catchment_polygon=self._parent_class.mymesh.catchment_polygon,
+                ax_settings=default_ax_settings,
+                figure=[fig, ax],
+            )
+
+        [fig.delaxes(ax) for ax in axs.flatten() if not ax.has_data()]
+        default_fig_settings.change((fig, axs))
+
+        if default_fig_settings.figname is None or html_show:
+            if tools.with_reticulate():
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, axs
+
+    def plot_parameters(
+        self,
+        param="cp",
+        mask_active_cell=False,
+        vmin=0.0,
+        vmax=None,
+        ax_settings={},
+        fig_settings={},
+        html_show: bool = False,
+    ):
+        """
+        Plot a map of a Smash parameters
+        :param param: Name of the parameter to plot, defaults to "cp"
+        :type param: str, optional
+        :param mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
+        :type mask_active_cell: bool, False, optional
+        :param vmin: Minimum value of the colorbar, defaults to 0.0
+        :type vmin: float, optional
+        :param vmax: Maximum value of the colorbar, defaults to None
+        :type vmax: float, optional
+        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
+         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
+        :type ax_settings: dict, optional
+        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
+         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
+        :type fig_settings: dict, optional
+        :param html_show: Display the figure in an html page with your navigator, defaults
+         to False
+        :type html_show: bool, optional
+        """
+
+        fig_settings = plot.fig_properties(**fig_settings)
+
+        list_param = list(self._parent_class.mysmashmodel.rr_parameters.keys)
+        z = list_param.index(param)
+
+        if mask_active_cell:
+            mask = self._parent_class.mysmashmodel.mesh.active_cell
+        else:
+            mask = None
+
+        fig, axs = plt.subplots()
+
+        default_ax_settings = plot.ax_properties(
+            title=f"{param} parameters map",
+            xlabel="Coords X",
+            ylabel="Coords_Y",
+            clabel=f"{param} parameter value",
+            cmap="viridis",
+        )
+        default_ax_settings.update(**ax_settings)
+
+        fig, ax = plot.plot_image(
+            matrice=self._parent_class.mysmashmodel.rr_parameters.values[:, :, z],
+            bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
+            mask=mask,
+            vmin=vmin,
+            vmax=vmax,
+            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
+            ax_settings=default_ax_settings,
+        )
+
+        fig_settings.change((fig, axs))
+
+        if fig_settings.figname is None or html_show:
+            if tools.with_reticulate():
+                mpld3.show(fig, open_browser=True)
+            else:
+                fig.show()
+
+        # return fig, axs