smashbox.plot.plot

   1# -*- coding: utf-8 -*-
   2import matplotlib.pyplot as plt
   3import numpy as np
   4import matplotlib
   5from matplotlib.colors import ListedColormap
   6import pandas as pd
   7from pandas import DataFrame
   8from smashbox.stats import stats
   9from smashbox.tools import geo_toolbox
  10import datetime
  11from smash import Model
  12
  13import matplotlib.colors as mcolors
  14from matplotlib import cm
  15import colorsys
  16from mpl_toolkits.axes_grid1 import make_axes_locatable
  17
  18import os
  19import pandas as pd
  20from smashbox.init.param import param
  21
  22from smashbox.tools import tools
  23
  24
  25class plot_properties:
  26    """Class which handle differents properties of the matplotlib plot function.
  27    All attributes can be defined by the user and the object plot_properties can be
  28     passed to any smashbox plot function.
  29    """
  30
  31    def __init__(
  32        self,
  33        ls="-",
  34        lw=1.5,
  35        marker="",
  36        markersize=4,
  37        color="black",
  38        label="",
  39    ):
  40        self.ls = ls
  41        """The style of the line (see matplotlib documentation)"""
  42        self.lw = lw
  43        """The linewidth of the line (see matplotlib documentation)"""
  44        self.marker = marker
  45        """The style of the marker (see matplotlib documentation)"""
  46        self.markersize = markersize
  47        """The size of the marker (see matplotlib documentation)"""
  48        self.color = color
  49        """The color of the line (see matplotlib documentation)"""
  50        self.label = label
  51        """The label of the line (see matplotlib documentation)"""
  52
  53    def update(self, **kwargs):
  54        """Update the class attributes using kwarg (dictionnary)"""
  55        for key, values in kwargs.items():
  56            setattr(self, key, values)
  57
  58
  59class ax_properties:
  60    """Class which handle differents properties of the matplotlib ax object
  61    (see matplotlib documentation). All attributes can be defined by the user and the
  62     object ax_properties can be passed to any smashbox plot function.
  63    """
  64
  65    def __init__(
  66        self,
  67        title: str = None,
  68        xlabel: str = None,
  69        ylabel: str = None,
  70        clabel: str = None,
  71        font_ratio: int = 1,
  72        title_fontsize: int = 12,
  73        label_fontsize: int = 10,
  74        annotate_fontsize: int = 6,
  75        grid: bool = True,
  76        xscale: str | None = None,
  77        yscale: str | None = None,
  78        legend: bool = True,
  79        legend_loc: str = None,
  80        legend_fontsize: int = 8,
  81        xtics_fontsize: int = 8,
  82        ytics_fontsize: int = 8,
  83        cmap: str | None = None,
  84        xlim: tuple | list | None = (None, None),
  85        ylim: tuple | list | None = (None, None),
  86        xticklabels_rotation: int = 0,
  87        barlabel_fontsize=6,
  88    ):
  89
  90        self.title = title
  91        """The title of the graphic"""
  92        self.xlabel = xlabel
  93        """The label of the x axis"""
  94        self.ylabel = ylabel
  95        """The label of the y axis"""
  96        self.clabel = clabel
  97        """The label of the colorbar"""
  98        self.font_ratio = font_ratio
  99        """Ratio of the global fontsize"""
 100        self.title_fontsize = title_fontsize
 101        """The fontsize of the title"""
 102        self.label_fontsize = label_fontsize
 103        """The label fontsize"""
 104        self.annotate_fontsize = annotate_fontsize
 105        """The annotation fontsize in plot"""
 106        self.grid = grid
 107        """Set the grid (boolean), default True"""
 108        self.xscale = xscale
 109        """Scale of the x axis (see matplotlib documentation)"""
 110        self.yscale = yscale
 111        """Scale of the x axis (see matplotlib documentation)"""
 112        self.legend = legend
 113        """Set the legend, boolean, default is True"""
 114        self.legend_loc = legend_loc
 115        """Localisation of the legend"""
 116        self.legend_fontsize = legend_fontsize
 117        """The fontsize of the legend"""
 118        self.xtics_fontsize = xtics_fontsize
 119        """The fontsize of the xtics"""
 120        self.ytics_fontsize = ytics_fontsize
 121        """The fontsize of the ytics"""
 122        self.cmap = cmap
 123        """The name of the used colormap"""
 124        self.xlim = xlim
 125        """The limit of the x axis, tuple or list, default is (None,None)"""
 126        self.ylim = ylim
 127        """The limit of the y axis, tuple or list, default is (None,None)"""
 128        self.xticklabels_rotation = xticklabels_rotation
 129        """Angle of the xtics labels, float, default is 0."""
 130        self.barlabel_fontsize = barlabel_fontsize * self.font_ratio
 131        "Fontsize of the bar top label"
 132
 133    def update(self, **kwargs):
 134        """Update the class attributes using kwarg (dictionnary)"""
 135        for key, values in kwargs.items():
 136            setattr(self, key, values)
 137
 138    def change(self, figure):
 139        """Apply change to the current figure `figure`
 140        Parameter:
 141        ----------
 142        figure : list or tuple
 143            list of (fig, ax), figure and ax of a matplotlib subplot.
 144        Return:
 145        -------
 146            a tuple of the modified (fig,ax)
 147        """
 148        fig, ax = figure
 149
 150        plt.rcParams.update(plt.rcParamsDefault)
 151
 152        plt.rcParams.update(
 153            {
 154                "axes.labelsize": self.label_fontsize * self.font_ratio,
 155                "axes.titlesize": self.title_fontsize * self.font_ratio,
 156                "legend.fontsize": self.legend_fontsize * self.font_ratio,
 157                "figure.titlesize": self.title_fontsize * self.font_ratio,
 158                "xtick.labelsize": self.xtics_fontsize * self.font_ratio,
 159                "ytick.labelsize": self.ytics_fontsize * self.font_ratio,
 160            }
 161        )
 162
 163        if self.title is not None:
 164
 165            ax.set_title(
 166                self.title, fontsize=self.title_fontsize * self.font_ratio
 167            )
 168
 169        if self.xlabel is not None:
 170            ax.set_xlabel(
 171                self.xlabel, fontsize=self.label_fontsize * self.font_ratio
 172            )
 173
 174        if self.ylabel is not None:
 175            ax.set_ylabel(
 176                self.ylabel, fontsize=self.label_fontsize * self.font_ratio
 177            )
 178
 179        if self.grid:
 180            ax.grid(True, which="both", linestyle="--", alpha=0.5)
 181
 182        if self.xscale is not None:
 183            ax.set_xscale(self.xscale)
 184
 185        if self.yscale is not None:
 186            ax.set_xyscale(self.yscale)
 187
 188        if self.legend:
 189            ax.legend(
 190                loc=self.legend_loc,
 191                fontsize=self.legend_fontsize * self.font_ratio,
 192            )
 193
 194        if self.cmap is not None:
 195            plt.rc("image", cmap=self.cmap)
 196
 197        if self.ylim[0] is not None:
 198            ax.set_ylim(bottom=self.ylim[0])
 199
 200        if self.ylim[1] is not None:
 201            ax.set_ylim(top=self.ylim[1])
 202
 203        if self.xlim[0] is not None:
 204            ax.set_xlim(left=self.xlim[0])
 205
 206        if self.xlim[1] is not None:
 207            ax.set_xlim(right=self.xlim[1])
 208
 209        if self.xticklabels_rotation > 0:
 210            ax.set_xticklabels(
 211                ax.get_xticklabels(),
 212                rotation=self.xticklabels_rotation,
 213                ha="right",
 214            )
 215
 216        return fig, ax
 217
 218
 219class fig_properties:
 220    """Class which handle differents properties of the matplotlib fig object
 221    (see matplotlib documentation). All attributes can be defined by the user and the
 222     object ax_properties can be passed to any smashbox plot function.
 223    """
 224
 225    def __init__(
 226        self,
 227        figname=None,
 228        xsize=8,
 229        ysize=6,
 230        transparent=False,
 231        dpi=160,
 232        font_ratio=1,
 233        bbox_inches="tight",
 234    ):
 235
 236        self.figname = figname
 237        """Path to the figure name to be saved"""
 238        self.xsize = xsize
 239        """Width of the figure in inch"""
 240        self.ysize = ysize
 241        """Height of the figure in inch"""
 242        self.transparent = transparent
 243        """Use transparency when exporting the figure, default is False"""
 244        self.dpi = dpi
 245        """Résolution (dpi), int, default is 80"""
 246        self.font_ratio = font_ratio
 247        """Global font ratio"""
 248        self.bbox_inches = bbox_inches
 249        """Constraint of the boundingbox of each ax (see matplotlib docuentation)"""
 250
 251    def update(self, **kwargs):
 252        """Update the class attributes using kwarg (dictionnary)"""
 253
 254        for key, values in kwargs.items():
 255            setattr(self, key, values)
 256
 257    def change(self, figure):
 258        """Apply change to the current figure `figure`
 259        Parameter:
 260        ----------
 261        figure : list or tuple
 262            list of (fig, ax), figure and ax of a matplotlib subplot.
 263        Return:
 264        -------
 265            a tuple of the modified (fig,ax)
 266        """
 267
 268        fig, ax = figure
 269
 270        fig.set_figheight(self.ysize)
 271        fig.set_figwidth(self.xsize)
 272
 273        plt.rc(
 274            "font", size=plt.rcParams["font.size"] * self.font_ratio
 275        )  # controls default text sizes
 276        plt.rc(
 277            "axes", titlesize=plt.rcParams["axes.titlesize"] * self.font_ratio
 278        )  # fontsize of the axes title
 279        plt.rc(
 280            "axes", labelsize=plt.rcParams["axes.labelsize"] * self.font_ratio
 281        )  # fontsize of the x and y labels
 282        plt.rc(
 283            "xtick",
 284            labelsize=plt.rcParams["xtick.labelsize"] * self.font_ratio,
 285        )  # fontsize of the tick labels
 286        plt.rc(
 287            "ytick",
 288            labelsize=plt.rcParams["ytick.labelsize"] * self.font_ratio,
 289        )  # fontsize of the tick labels
 290        plt.rc(
 291            "legend",
 292            fontsize=plt.rcParams["legend.fontsize"] * self.font_ratio,
 293        )  # legend fontsize
 294        plt.rc(
 295            "figure",
 296            titlesize=plt.rcParams["figure.titlesize"] * self.font_ratio,
 297        )  # fontsize of the figure title
 298
 299        if self.figname is not None:
 300
 301            head_path, basename = os.path.split(self.figname)
 302
 303            if len(head_path) > 0 and not os.path.exists(head_path):
 304                os.makedirs(head_path)
 305
 306            fig.savefig(
 307                self.figname,
 308                transparent=self.transparent,
 309                dpi=self.dpi,
 310                bbox_inches=self.bbox_inches,
 311            )
 312
 313        return fig, ax
 314
 315
 316@tools.autocast_args
 317def save_figure(
 318    fig=None, figname="myfigure", xsize=8, ysize=6, transparent=False, dpi=80
 319):
 320    """
 321    Save a figure.
 322    Parameters:
 323    -----------
 324    fig: fig object returned by matplotlib.subplot
 325        the figure to save
 326    figname: str
 327        Path to the figure
 328    xsize: int
 329        width of the figure in inch
 330    ysize: int
 331        height of the figure in inch
 332    transparent: bool, default is False
 333        use transparency
 334    dpi : int
 335        resolution of the figure, default is 80
 336    """
 337    fig.set_size_inches(xsize, ysize, forward=True)
 338    fig.savefig(figname, transparent=transparent, dpi=dpi, bbox_inches="tight")
 339
 340
 341def generate_palette(base_color, n, variation="hue"):
 342    """
 343    Generate a palette of colors from a base color.
 344    Parameter:
 345    ---------
 346    base_color: str
 347        matplotlib color string
 348    n: int
 349        number of color to generate
 350    variation: 'hue' | 'brightness'
 351        how to generate the color palette, by changing the hue or the brighness of the base color.
 352    Return: a list of colors
 353    """
 354    # Convertir la couleur de base en format RGB normalisé (0-1)
 355    rgb = mcolors.to_rgb(base_color)
 356
 357    # Convertir en HSV
 358    h, s, v = colorsys.rgb_to_hsv(*rgb)
 359
 360    # Générer n couleurs en modifiant la teinte ou valeur
 361    palette = []
 362    for i in range(n):
 363        new_h = h
 364        if variation == "hue":
 365            new_h = (h + i / n) % 1.0  # cycle dans le cercle chromatique
 366        new_v = v
 367        if variation == "brightness":
 368            new_v = max(
 369                0.1, min(1.0, v * (0.5 + i / (2 * n)))
 370            )  # éviter le noir complet
 371
 372        new_rgb = colorsys.hsv_to_rgb(new_h, s, new_v)
 373        palette.append(new_rgb)
 374
 375    return palette
 376
 377
 378@tools.autocast_args
 379def plot_chro(
 380    data: np.ndarray = np.zeros(shape=(1, 10)),
 381    t_axis: int = 1,
 382    outlets_name: list | tuple = [],
 383    columns: list | tuple = [],
 384    dt: float = 0.0,
 385    xtics: list | tuple = [],
 386    date_range: list = None,
 387    figure=None,
 388    ax_settings: dict | ax_properties = ax_properties(),
 389    fig_settings: dict | fig_properties = fig_properties(),
 390    plot_settings: dict | plot_properties = plot_properties(),
 391):
 392    """
 393    Plot a temporal chonic of values
 394    Parameters:
 395    -----------
 396    data: np.ndarray of dimenion 2.
 397        data to plot as a matrix of 2 dimension.
 398    t_axis : int
 399        the axis of the time in data, default is 1
 400    outlets_name: list
 401        the list of the outlets name
 402    columns : list
 403        the column to be plotted in t_axis direction
 404    dt: float
 405        the timestep
 406    xtics : list
 407        list of date for the xtics. The format must be automatically read by numpy.Datetime
 408    date_range: list
 409        list of [date_start, date_end, timedelta] to generate the xtics
 410    figure: tuple
 411        input figure as (fig,ax) to add a new curve
 412    ax_settings: dict or class ax_properties
 413        object or dict with any attribute of class ax_properties
 414    fig_settings: dict or class ax_properties
 415        object or dict with any attribute of class fig_settings
 416    plot_settings: dict or class plot_properties
 417        object or dict with any attribute of class plot_settings
 418
 419    """
 420
 421    if isinstance(ax_settings, dict):
 422        ax_settings = ax_properties(**ax_settings)
 423    else:
 424        ax_settings = ax_properties(**ax_settings.__dict__)
 425
 426    if isinstance(fig_settings, dict):
 427        fig_settings = fig_properties(**fig_settings)
 428    else:
 429        fig_settings = fig_properties(**fig_settings.__dict__)
 430
 431    if isinstance(plot_settings, dict):
 432        plot_settings = plot_properties(**plot_settings)
 433    else:
 434        plot_settings = plot_properties(**plot_settings.__dict__)
 435
 436    data = np.moveaxis(data, t_axis, 0)
 437
 438    if figure is not None:
 439        fig, ax = figure
 440    else:
 441        fig, ax = plt.subplots()
 442
 443    fig, ax = ax_settings.change(figure=(fig, ax))
 444
 445    if len(xtics) == 0:
 446        xtics = np.arange(0, data.shape[0])
 447        if dt > 0:
 448            xtics = xtics * dt
 449    else:
 450        for i in range(len(xtics)):
 451            xtics[i] = np.datetime64(xtics[i])
 452
 453    if date_range is not None:
 454        if len(date_range) != 3:
 455            raise ValueError(
 456                "date_range must have a length of 3: [date_start, date_end, step (s)]"
 457            )
 458        xtics = np.arange(
 459            np.datetime64(date_range[0]),
 460            np.datetime64(
 461                date_range[1] + pd.Timedelta(seconds=int(date_range[2]))
 462            ),
 463            np.timedelta64(int(date_range[2]), "s"),
 464        )
 465
 466    if len(columns) > 0:
 467
 468        args = plot_settings.__dict__.copy()
 469        print(args)
 470        del args["label"]
 471        del args["color"]
 472
 473        palette = generate_palette(plot_settings.color, len(columns))
 474
 475        for i in columns:
 476            ax.plot(
 477                xtics[:],
 478                data[:, i],
 479                **args,
 480                label=outlets_name[i],
 481                color=palette[i],
 482            )
 483    else:
 484        ax.plot(xtics[:], data[:, 0], **plot_settings.__dict__)
 485
 486    fig, ax = ax_settings.change(figure=(fig, ax))
 487    fig, ax = fig_settings.change(figure=(fig, ax))
 488
 489    return fig, ax
 490
 491
 492def plot_hydrograph(
 493    model: Model | None = None,
 494    columns: list | tuple = [],
 495    outlets_name: list | tuple = [],
 496    plot_rainfall: bool = True,
 497    plot_qobs: bool = True,
 498    figure: list | tuple | None = None,
 499    ax_settings: dict | ax_properties = {},
 500    fig_settings: dict | fig_properties = {},
 501    plot_settings_sim: dict | plot_properties = {},
 502    plot_settings_obs: dict | plot_properties = {},
 503):
 504    """
 505    Plot an hydrograph from a smash model
 506    Parameters:
 507    -----------
 508    model: a smash model object
 509        a smash model object
 510    outlets_name: list
 511        the list of the outlets name
 512    columns : list
 513        the column to be plotted in t_axis direction
 514    figure: tuple
 515        input figure as (fig,ax) to add a new curve
 516    ax_settings: dict or class ax_properties
 517        object or dict with any attribute of class ax_properties
 518    fig_settings: dict or class ax_properties
 519        object or dict with any attribute of class fig_settings
 520    plot_settings_sim: dict or class ax_properties
 521        object or dict with any attribute of class plot_settings.Control the simulated curve
 522    plot_settings_obs: dict or class ax_properties
 523        object or dict with any attribute of class plot_settings. Control the observed curve
 524
 525    """
 526    if model is None:
 527        raise ValueError("Input smash model object is None.")
 528
 529    if isinstance(ax_settings, dict):
 530        default_ax_settings = ax_properties(
 531            xlabel="Time",
 532            ylabel="discharges m^3/s",
 533            xtics_fontsize=10,
 534            ytics_fontsize=10,
 535        )
 536        default_ax_settings.update(**ax_settings)
 537    else:
 538        default_ax_settings = ax_properties(**ax_settings.__dict__)
 539
 540    if isinstance(fig_settings, dict):
 541        fig_settings = fig_properties(**fig_settings)
 542    else:
 543        fig_settings = fig_properties(**fig_settings.__dict__)
 544
 545    if isinstance(plot_settings_sim, dict):
 546        default_plot_settings_sim = plot_properties(
 547            ls="-",
 548            lw="2",
 549            marker="",
 550            markersize=4,
 551            color="blue",
 552            label="Sim",
 553        )
 554        default_plot_settings_sim.update(**plot_settings_sim)
 555    else:
 556        default_plot_settings_sim = plot_properties(
 557            **plot_settings_sim.__dict__
 558        )
 559
 560    # default color for multi curves: same color but different line type
 561    if len(columns) >= 2:
 562        color = "blue"
 563    else:
 564        color = "black"
 565
 566    if isinstance(plot_settings_obs, dict):
 567        default_plot_settings_obs = plot_properties(
 568            ls="--",
 569            lw="1.5",
 570            marker="",
 571            markersize=4,
 572            color=color,
 573            label="Obs",
 574        )
 575        default_plot_settings_obs.update(**plot_settings_obs)
 576    else:
 577        default_plot_settings_obs = plot_properties()
 578
 579    # manage date here
 580    date_deb = datetime.datetime.fromisoformat(
 581        model.setup.start_time
 582    ) + datetime.timedelta(seconds=int(model.setup.dt))
 583    date_end = datetime.datetime.fromisoformat(model.setup.end_time)
 584    date_range = [date_deb, date_end, model.setup.dt]
 585
 586    if figure is None:
 587        if plot_rainfall:
 588            fig, (ax2, ax1) = plt.subplots(2, 1, height_ratios=[1, 4])
 589            fig.subplots_adjust(hspace=0)
 590            figure = [fig, ax1, ax2]
 591        else:
 592            fig, ax2 = plt.subplots()
 593            figure = [fig, ax1]
 594    else:
 595        if plot_rainfall:
 596            fig = figure[0]
 597            ax1 = figure[1]
 598            ax2 = figure[2]
 599        else:
 600            fig = figure[0]
 601            ax1 = figure[1]
 602
 603    fig, ax = default_ax_settings.change(figure=(fig, ax1))
 604
 605    if plot_qobs:
 606        fig, ax1 = plot_chro(
 607            np.where(model.response_data.q < 0, np.nan, model.response_data.q),
 608            date_range=date_range,
 609            columns=columns,
 610            outlets_name=["obs_" + name for name in outlets_name],
 611            figure=(fig, ax1),
 612            ax_settings=default_ax_settings,
 613            fig_settings=fig_settings,
 614            plot_settings=default_plot_settings_obs,
 615        )
 616
 617    fig, ax1 = plot_chro(
 618        model.response.q,
 619        date_range=date_range,
 620        columns=columns,
 621        outlets_name=["sim_" + name for name in outlets_name],
 622        figure=(fig, ax1),
 623        ax_settings=default_ax_settings,
 624        fig_settings=fig_settings,
 625        plot_settings=default_plot_settings_sim,
 626    )
 627
 628    xtics = np.arange(
 629        np.datetime64(date_range[0]),
 630        np.datetime64(
 631            date_range[1] + datetime.timedelta(seconds=int(date_range[2]))
 632        ),
 633        np.timedelta64(int(date_range[2]), "s"),
 634    )
 635
 636    axes_list = [ax1]
 637
 638    if plot_rainfall:
 639
 640        if len(columns) > 0:
 641            col = columns[0]
 642        else:
 643            col = 0
 644
 645        ax2.bar(
 646            xtics[:],
 647            model.atmos_data.mean_prcp[col, :],
 648            label="Average rainfall (mm)",
 649            width=np.timedelta64(int(date_range[2]), "s"),
 650            color="blue",
 651        )
 652
 653        ax2.invert_yaxis()
 654        ax2.grid(alpha=0.7, ls="--")
 655        ax2.get_xaxis().set_visible(False)
 656        ax2.set_ylim(
 657            bottom=1.2 * max(model.atmos_data.mean_prcp[0, :]), top=0.0
 658        )
 659        ax2.set_ylabel("Average rainfall (mm)")
 660
 661        axes_list.append(ax2)
 662
 663    fig, ax = fig_settings.change(figure=(fig, tuple(axes_list)))
 664
 665    return fig, ax
 666
 667
 668def plot_catchment_surface_error(
 669    mesh: dict = None,
 670    ax_settings: dict | ax_properties = {},
 671    fig_settings: dict | fig_properties = {},
 672):
 673    """
 674    Plot the misfit criteria between the simulated and observed discharges.
 675    Parameters:
 676    -----------
 677    values: np.ndarray
 678        The result of the discharge misfit for all outlets.
 679    names: np.ndarray
 680        Outlets name or code stored in an np.ndarray.
 681    columns: list | None
 682        Columns of the np.ndarray to plot
 683    misfit: str
 684        Criteria to plot. choice are ['nse', 'nnse', 'rmse', 'nrmse', 'se', 'kge']"
 685    figure: tuple
 686        input figure as (fig,ax) to add a new curve
 687    ax_settings: dict or class ax_properties
 688        object or dict with any attribute of class ax_properties
 689    fig_settings: dict or class ax_properties
 690        object or dict with any attribute of class fig_settings
 691    """
 692
 693    if isinstance(ax_settings, dict):
 694        default_ax_settings = ax_properties(
 695            title="Catchment surface error (Ssim-Sobs)/Sobs *100",
 696            ylabel="Surface error %",
 697            xlabel="Outlets",
 698            xticklabels_rotation=45,
 699            xtics_fontsize=6,
 700        )
 701        default_ax_settings.update(**ax_settings)
 702    else:
 703        default_ax_settings = ax_properties(**ax_settings.__dict__)
 704
 705    if isinstance(fig_settings, dict):
 706        fig_settings = fig_properties(**fig_settings)
 707    else:
 708        fig_settings = fig_properties(**fig_settings.__dict__)
 709
 710    if len(mesh["code"]) == 0:
 711        print("Cannot plot this, the mesh has no gauge !")
 712        return None, None
 713
 714    plt.rcParams.update(plt.rcParamsDefault)
 715    fig, ax = plt.subplots()
 716    fig, ax = default_ax_settings.change(figure=(fig, ax))
 717
 718    surface_error = (mesh["area_dln"] - mesh["area"]) / mesh["area"] * 100
 719
 720    fig, ax = default_ax_settings.change(figure=(fig, ax))
 721    bar_container = ax.bar(
 722        mesh["code"], surface_error, color="grey", tick_label=mesh["code"]
 723    )
 724
 725    ax.bar_label(
 726        bar_container,
 727        fmt=lambda x: f"{x:.2f}",
 728        fontsize=default_ax_settings.barlabel_fontsize,
 729    )
 730
 731    fig, ax = default_ax_settings.change(figure=(fig, ax))
 732    fig, ax = fig_settings.change(figure=(fig, ax))
 733
 734    return fig, ax
 735
 736
 737def plot_catchment_surface_consistency(
 738    mesh: dict = None,
 739    label: bool = True,
 740    ax_settings: dict | ax_properties = {},
 741    fig_settings: dict | fig_properties = {},
 742    plot_settings: dict | plot_properties = {},
 743):
 744    """
 745    Plot the modeled surface vs the observed surface
 746    Parameters:
 747    -----------
 748    mesh: dict, optional
 749        The mesh of the Smash model, defaults to None
 750    ax_settings: dict or class ax_properties
 751        object or dict with any attribute of class ax_properties
 752    fig_settings: dict or class ax_properties
 753        object or dict with any attribute of class fig_settings
 754    plot_settings: dict or class plot_properties
 755        object or dict with any attribute of class plot_settings.Control the simulated curve
 756    """
 757
 758    if isinstance(ax_settings, dict):
 759        default_ax_settings = ax_properties(
 760            title="Modeled and observed surface consistency",
 761            ylabel="Modeled surface",
 762            xlabel="Observed surface",
 763        )
 764        default_ax_settings.update(**ax_settings)
 765    else:
 766        default_ax_settings = ax_properties(**ax_settings.__dict__)
 767
 768    if isinstance(fig_settings, dict):
 769        fig_settings = fig_properties(**fig_settings)
 770    else:
 771        fig_settings = fig_properties(**fig_settings.__dict__)
 772
 773    if isinstance(plot_settings, dict):
 774        default_plot_settings = plot_properties(
 775            marker="+",
 776            markersize=12,
 777            color="blue",
 778        )
 779        default_plot_settings.update(**plot_settings)
 780    else:
 781        default_plot_settings = plot_properties(**plot_settings.__dict__)
 782
 783    if len(mesh["code"]) == 0:
 784        print("Cannot plot this, the mesh has no gauge !")
 785        return None, None
 786
 787    surface_model = mesh["area_dln"] / 1000.0**2.0
 788    surface_obs = mesh["area"] / 1000.0**2.0
 789
 790    plt.rcParams.update(plt.rcParamsDefault)
 791    fig, ax = plt.subplots()
 792    fig, ax = default_ax_settings.change(figure=(fig, ax))
 793
 794    ax.plot(
 795        surface_obs,
 796        surface_model,
 797        markersize=default_plot_settings.markersize,
 798        marker=default_plot_settings.marker,
 799        color=default_plot_settings.color,
 800        linestyle="None",
 801    )
 802    ax.plot(
 803        np.linspace(min(surface_obs), max(surface_obs), 10),
 804        np.linspace(min(surface_obs), max(surface_obs), 10),
 805        linewidth=2,
 806        color="grey",
 807    )
 808
 809    if label:
 810        ha = ("left", "right")
 811        for i, label in enumerate(mesh["code"]):
 812            ax.annotate(
 813                label,  # this is the text
 814                (
 815                    surface_obs[i],
 816                    surface_model[i],
 817                ),  # these are the coordinates to position the label
 818                textcoords="data",  # how to position the text
 819                xytext=(
 820                    surface_obs[i],
 821                    surface_model[i],
 822                ),  # distance from text to points (x,y)
 823                ha=ha[
 824                    i % 2
 825                ],  # horizontal alignment can be left, right or center
 826                color="red",
 827                fontsize=default_ax_settings.annotate_fontsize,
 828            )
 829
 830    ax.set(
 831        xlabel=default_ax_settings.xlabel, ylabel=default_ax_settings.ylabel
 832    )
 833
 834    fig, ax = fig_settings.change(figure=(fig, ax))
 835
 836    return fig, ax
 837
 838
 839def plot_mesh(
 840    mesh: dict = None,
 841    coef_hydro: float = 99.0,
 842    catchment_polygon: None | DataFrame = None,
 843    ax_settings: dict | ax_properties = {},
 844    fig_settings: dict | fig_properties = {},
 845):
 846    """
 847    Plot the mesh of a smash model
 848    Parameters:
 849    -----------
 850    mesh: a smash mesh as dictionary
 851        a smash model object
 852    coef_hydro: float
 853        the coefficient to colorize the hydrographic network accodring the cumulative
 854        surface. default is 99% so that 99% of the cell will be hidden.
 855    ax_settings: dict or class ax_properties
 856        object or dict with any attribute of class ax_properties
 857    fig_settings: dict or class ax_properties
 858        object or dict with any attribute of class fig_settings
 859    """
 860
 861    if mesh is not None:
 862        if isinstance(mesh, dict):
 863            pass
 864        else:
 865            raise ValueError("mesh must be a dict")
 866    else:
 867        raise ValueError(
 868            "model or mesh are mandatory and must be a dict or a smash Model object"
 869        )
 870
 871    if isinstance(ax_settings, dict):
 872        default_ax_settings = ax_properties(
 873            title="Mesh of the Smash model",
 874            xlabel="x_coords",
 875            ylabel="y_coords",
 876        )
 877        default_ax_settings.update(**ax_settings)
 878    else:
 879        default_ax_settings = ax_properties(**ax_settings.__dict__)
 880
 881    if isinstance(fig_settings, dict):
 882        fig_settings = fig_properties(**fig_settings)
 883    else:
 884        fig_settings = fig_properties(**fig_settings.__dict__)
 885
 886    # mesh["active_cell"]
 887    gauge = mesh["gauge_pos"]
 888    stations = mesh["code"]
 889    flow_acc = mesh["flwacc"]
 890    na = mesh["active_cell"] == 0
 891
 892    flow_accum_bv = np.where(na, 0.0, flow_acc.data / 1000000.0)
 893    surfmin = (1.0 - coef_hydro / 100.0) * np.nanmax(flow_accum_bv)
 894    mask_flow = flow_accum_bv < surfmin
 895    flow_plot = np.where(mask_flow, np.nan, flow_accum_bv)
 896    flow_plot = np.where(na, np.nan, flow_plot)
 897
 898    plt.rcParams.update(plt.rcParamsDefault)
 899    fig, ax = plt.subplots()
 900    fig, ax = default_ax_settings.change(figure=(fig, ax))
 901
 902    bbox = geo_toolbox.get_bbox_from_smash_mesh(mesh)
 903    extent = (bbox["left"], bbox["right"], bbox["bottom"], bbox["top"])
 904
 905    active_cell = np.where(na, np.nan, mesh["active_cell"])
 906    cmap = ListedColormap(["lightgray"])
 907    ax.imshow(active_cell, cmap=cmap, extent=extent)
 908
 909    myblues = matplotlib.colormaps["Blues"]
 910    cmp = ListedColormap(myblues(np.linspace(0.30, 1.0, 265)))
 911    im = ax.imshow(flow_plot, cmap=cmp, extent=extent)
 912
 913    if catchment_polygon is not None:
 914        # catchment_polygon = gpd.read_file(outlets_shapefile)
 915        catchment_polygon.plot(ax=ax, facecolor="none", edgecolor="black")
 916
 917    # create an axes on the right side of ax. The width of cax will be 5%
 918    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
 919    divider = make_axes_locatable(ax)
 920    cax = divider.append_axes("right", size="5%", pad=0.05)
 921
 922    fig.colorbar(
 923        im,
 924        cmap="Blues",
 925        ax=ax,
 926        label="Cumulated surface (km²)",
 927        shrink=0.75,
 928        cax=cax,
 929    )
 930
 931    pos_y = -5
 932    ha = "right"
 933    for i in range(len(stations)):
 934        if pos_y > 0:
 935            pos_y = -10
 936        else:
 937            pos_y = 5
 938        # pos_y=-1*pos_y
 939
 940        if ha == "right":
 941            ha = "left"
 942            pos_x = 5
 943        else:
 944            ha = "right"
 945            # pos_x = -5
 946
 947        coord = geo_toolbox.rowcol_to_xy(
 948            gauge[i][0],
 949            gauge[i][1],
 950            mesh["xmin"],
 951            mesh["ymax"],
 952            mesh["xres"],
 953            mesh["yres"],
 954        ) + np.array(
 955            [
 956                mesh["dx"][gauge[i][0], gauge[i][1]] / 2,
 957                -mesh["dx"][gauge[i][0], gauge[i][1]] / 2,
 958            ]
 959        )
 960
 961        code = stations[i]
 962        ax.plot(coord[0], coord[1], color="green", marker="o", markersize=6)
 963        ax.annotate(
 964            code,  # this is the text
 965            # these are the coordinates to position the label
 966            (coord[0], coord[1]),
 967            # textcoords="offset points",  # how to position the text
 968            # xytext=(pos_x, pos_y),  # distance from text to points (x,y)
 969            textcoords="data",  # how to position the text
 970            xytext=(coord[0], coord[1]),  # distance from text to points (x,y)
 971            ha=ha,  # horizontal alignment can be left, right or center
 972            color="red",
 973            fontsize=10,
 974        )
 975
 976    fig, ax = default_ax_settings.change(figure=(fig, ax))
 977
 978    fig, ax = fig_settings.change(figure=(fig, ax))
 979
 980    return fig, ax
 981
 982
 983def plot_xy_quantile(
 984    res_quantile,
 985    X,
 986    Y,
 987    res_quantile_obs=None,
 988    gauge_pos=None,
 989    figure=None,
 990    ax_settings: dict | ax_properties = {},
 991    fig_settings: dict | fig_properties = {},
 992    plot_settings: dict | plot_properties = {},
 993):
 994    """
 995    Plot the discharges quantiles fitting at X,Y coordinates.
 996    Parameters:
 997    -----------
 998    res_quantile: dict
 999        The result of the discharge quantile computation.
1000    res_quantile_obs: dict
1001        The results of the observed discharges quantile. res_quantile_obs is a dict and must be computed by the function smashbox.stats.stats.quantile_obs()
1002    gauge_pos: int
1003        gauge_pos is the index of gauge in the Smash mesh for which the quantile_discharge are provided to the function.
1004    X: int
1005        Coordinates of the pixel in the row directions (X means row)
1006    Y: int
1007        Coordinates of the pixel in the column directions (Y means column)
1008    figure: tuple
1009        input figure as (fig,ax) to add a new curve
1010    ax_settings: dict or class ax_properties
1011        object or dict with any attribute of class ax_properties
1012    fig_settings: dict or class ax_properties
1013        object or dict with any attribute of class fig_settings
1014    """
1015    if isinstance(ax_settings, dict):
1016        default_ax_settings = ax_properties(
1017            xscale="log",
1018            xlabel=f"Return period (*{res_quantile['chunk_size']} days)",
1019            ylabel="Discharges (m³/s)",
1020            grid=True,
1021            legend=True,
1022        )
1023        default_ax_settings.update(**ax_settings)
1024    else:
1025        default_ax_settings = ax_properties(**ax_settings.__dict__)
1026
1027    if isinstance(fig_settings, dict):
1028        fig_settings = fig_properties(**fig_settings)
1029    else:
1030        fig_settings = fig_properties(**fig_settings.__dict__)
1031
1032    if isinstance(plot_settings, dict):
1033        default_plot_settings = plot_properties(markersize=10)
1034        default_plot_settings.update(**plot_settings)
1035    else:
1036        default_plot_settings = plot_properties(**plot_settings.__dict__)
1037
1038    quantile = res_quantile["Q_th"][X, Y]
1039    maxima = res_quantile["maxima"][X, Y]
1040    T_emp = res_quantile["T_emp"]
1041    loc = res_quantile["fit_loc"][X, Y]
1042    scale = res_quantile["fit_scale"][X, Y]
1043    shape = res_quantile["fit_shape"][X, Y]
1044    fit = res_quantile["fit"]
1045
1046    sorted_data = np.sort(maxima)
1047
1048    plt.rcParams.update(plt.rcParamsDefault)
1049    if figure is None:
1050        fig, ax = plt.subplots()
1051    else:
1052        fig, ax = figure
1053
1054    fig, ax = default_ax_settings.change(figure=(fig, ax))
1055
1056    if res_quantile_obs is not None and len(res_quantile_obs.keys()) > 0:
1057        if gauge_pos is None:
1058            raise ValueError(
1059                "gauge_pos is None. gauge_pos argument must be an integer corresponding to the gauge index."
1060            )
1061        maxima_obs = res_quantile_obs["maxima"][gauge_pos, :]
1062        T_emp_obs = res_quantile_obs["Temp"][gauge_pos, :]
1063
1064        ax.plot(
1065            T_emp_obs,
1066            maxima_obs,
1067            "o",
1068            label="Observed",
1069            color="black",
1070            markersize=default_plot_settings.markersize,
1071        )
1072
1073    ax.plot(
1074        T_emp,
1075        sorted_data,
1076        "o",
1077        label="Empirical",
1078        markersize=default_plot_settings.markersize,
1079    )
1080
1081    ax.plot(
1082        res_quantile["T"],
1083        quantile,
1084        "x",
1085        label="Theorical",
1086        markersize=default_plot_settings.markersize,
1087    )
1088
1089    Trange = np.linspace(1.1, np.nanmax(res_quantile["T"]), 50)
1090
1091    if fit == "gumbel":
1092        ax.plot(
1093            Trange,
1094            [stats.quantile_gumbel(T, loc, scale) for T in Trange],
1095            "r--",
1096            label=f"{fit} fitted",
1097            lw=default_plot_settings.lw,
1098        )
1099
1100    if fit == "gev":
1101        ax.plot(
1102            Trange,
1103            [stats.quantile_gev(T, shape, loc, scale) for T in Trange],
1104            "r--",
1105            label=f"{fit} fitted",
1106            lw=default_plot_settings.lw,
1107        )
1108
1109    if "Umax" in res_quantile.keys() and "Umin" in res_quantile.keys():
1110        if (
1111            res_quantile["Umax"] is not None
1112            and res_quantile["Umin"] is not None
1113        ):
1114            ax.plot(
1115                res_quantile["T"],
1116                res_quantile["Umax"][X, Y],
1117                "r--",
1118                label="Uncertainties (max)",
1119                color="grey",
1120                lw=default_plot_settings.lw,
1121            )
1122            ax.plot(
1123                res_quantile["T"],
1124                res_quantile["Umin"][X, Y],
1125                "r--",
1126                label="Uncertainties (min)",
1127                color="grey",
1128                lw=default_plot_settings.lw,
1129            )
1130
1131    fig, ax = default_ax_settings.change(figure=(fig, ax))
1132    fig, ax = fig_settings.change(figure=(fig, ax))
1133
1134    return fig, ax
1135
1136
1137def plot_image(
1138    matrice=np.zeros(shape=(2, 2)),
1139    bbox=None,
1140    vmin=None,
1141    vmax=None,
1142    mask=None,
1143    extend=None,
1144    catchment_polygon=None,
1145    figure=None,
1146    ax_settings: dict | ax_properties = {},
1147    fig_settings: dict | fig_properties = {},
1148):
1149    """
1150    Function for plotting a matrix as an image
1151
1152    Parameters
1153    ----------
1154    matrice : numpy array
1155        Matrix to be plotted
1156    bbox : list
1157        ["left","right","bottom","top"] bouding box to put x and y coordinates instead
1158    of the shape of the matrix
1159    vmin: real,
1160        minimum z value
1161    vmax: real,
1162        maximum z value
1163    mask: integer, matrix, shape of matice, contain 0 for pixels that should not be plotted
1164    catchment_polygon: dataframe containing some polygon to be plotted.
1165    Ideally it must contain the boundaries of the catchment as a polygon from a shp file
1166    read by geopanda.
1167    figure: tuple
1168        input figure as (fig,ax) to add a new curve
1169    ax_settings: dict or class ax_properties
1170        object or dict with any attribute of class ax_properties
1171    fig_settings: dict or class ax_properties
1172        object or dict with any attribute of class fig_settings
1173
1174    Examples
1175    ----------
1176    smash.utils.plot_image(mesh_france['drained_area'],bbox=bbox,title="Surfaces
1177                           drainées",xlabel="Longitude",ylabel="Latitude",zlabel="Surfaces drainées
1178                           km^2",vmin=0.0,vmax=1000,mask=mesh_france['global_active_cell'])
1179
1180    """
1181
1182    if isinstance(ax_settings, dict):
1183        ax_settings = ax_properties(**ax_settings)
1184    else:
1185        ax_settings = ax_properties(**ax_settings.__dict__)
1186
1187    if isinstance(fig_settings, dict):
1188        fig_settings = fig_properties(**fig_settings)
1189    else:
1190        fig_settings = fig_properties(**fig_settings.__dict__)
1191
1192    matrice = np.float32(matrice)
1193
1194    if bbox is not None:
1195        extent = [
1196            bbox["left"],
1197            bbox["right"],
1198            bbox["bottom"],
1199            bbox["top"],
1200        ]
1201    else:
1202        extent = None
1203
1204    if mask is not None:
1205        matrice[np.where(mask == 0)] = np.nan
1206
1207    plt.rcParams.update(plt.rcParamsDefault)
1208    if figure is None:
1209        fig, ax = plt.subplots()
1210    else:
1211        fig, ax = figure
1212
1213    if vmax is None:
1214        vmax = np.nanmax(matrice)
1215    if vmin is None:
1216        vmin = np.nanmin(matrice)
1217
1218    fig, ax = ax_settings.change(figure=(fig, ax))
1219
1220    # do it first otherwise crash if vmin>min de polygon
1221    if catchment_polygon is not None:
1222        catchment_polygon.plot(ax=ax, facecolor="none", edgecolor="black")
1223
1224    im = ax.imshow(
1225        matrice, extent=extent, vmin=vmin, vmax=vmax, cmap=ax_settings.cmap
1226    )
1227
1228    # create an axes on the right side of ax. The width of cax will be 5%
1229    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
1230    divider = make_axes_locatable(ax)
1231    cax = divider.append_axes("right", size="5%", pad=0.05)
1232
1233    plt.colorbar(im, label=ax_settings.clabel, cax=cax)
1234
1235    fig, ax = ax_settings.change(figure=(fig, ax))
1236    fig, ax = fig_settings.change(figure=(fig, ax))
1237
1238    return (fig, ax)
1239
1240
1241def plot_misfit(
1242    values: np.ndarray = [],
1243    names: np.ndarray = [],
1244    columns: list | None = None,
1245    misfit: str = "nse",
1246    figure: list | tuple | None = None,
1247    ax_settings: dict | ax_properties = {},
1248    fig_settings: dict | fig_properties = {},
1249):
1250    """
1251    Plot the misfit criteria between the simulated and observed discharges.
1252    Parameters:
1253    -----------
1254    values: np.ndarray
1255        The result of the discharge misfit for all outlets.
1256    names: np.ndarray
1257        Outlets name or code stored in an np.ndarray.
1258    columns: list | None
1259        Columns of the np.ndarray to plot
1260    misfit: str
1261        Criteria to plot. choice are ['nse', 'nnse', 'rmse', 'nrmse', 'se', 'kge']"
1262    figure: tuple
1263        input figure as (fig,ax) to add a new curve
1264    ax_settings: dict or class ax_properties
1265        object or dict with any attribute of class ax_properties
1266    fig_settings: dict or class ax_properties
1267        object or dict with any attribute of class fig_settings
1268    """
1269
1270    if isinstance(ax_settings, dict):
1271        default_ax_settings = ax_properties(
1272            ylabel=f"{misfit} criteria",
1273            xlabel="Gauges stations",
1274            grid=True,
1275            legend=True,
1276            xticklabels_rotation=45,
1277            xtics_fontsize=8,
1278        )
1279        default_ax_settings.update(**ax_settings)
1280    else:
1281        default_ax_settings = ax_properties(**ax_settings.__dict__)
1282
1283    if isinstance(fig_settings, dict):
1284        fig_settings = fig_properties(**fig_settings)
1285    else:
1286        fig_settings = fig_properties(**fig_settings.__dict__)
1287
1288    if len(names) == 0:
1289        names = np.arange(len(values))
1290
1291    if columns is not None:
1292        values = values[columns]
1293        names = names[columns]
1294
1295    # remove nan from plot
1296    columns = list(np.isnan(values) == False)
1297    # print(columns)
1298    if len(columns) > 0:
1299        values = values[columns]
1300        names = names[columns]
1301
1302    if figure is None:
1303        fig, ax = plt.subplots()
1304    else:
1305        fig, ax = figure
1306
1307    fig, ax = default_ax_settings.change(figure=(fig, ax))
1308    bar_container = ax.bar(names, values, color="grey", tick_label=names)
1309
1310    ax.bar_label(
1311        bar_container,
1312        fmt=lambda x: f"{x:.2f}",
1313        fontsize=default_ax_settings.barlabel_fontsize,
1314    )
1315
1316    fig, ax = default_ax_settings.change(figure=(fig, ax))
1317    fig, ax = fig_settings.change(figure=(fig, ax))
1318
1319    return fig, ax
1320
1321
1322def plot_outlet_stats(
1323    values_sim: np.ndarray | None = None,
1324    values_obs: np.ndarray | None = None,
1325    names: np.ndarray = [],
1326    columns: list | None = [],
1327    stat: str = "max",
1328    figure: list | tuple | None = None,
1329    ax_settings: dict | ax_properties = {},
1330    fig_settings: dict | fig_properties = {},
1331):
1332    """
1333    Plot a statistical criteria at a given list of outlet.
1334    Parameters:
1335    -----------
1336    values_sim: np.ndarray or None
1337        The result of the simulated stat for all outlets.
1338    values_obs: np.ndarray or None
1339        The result of the observed stat for all outlets.
1340    names: np.ndarray
1341        Outlets name or code stored in an np.ndarray.
1342    columns: list | None
1343        Columns of the np.ndarray to plot
1344    stat: str
1345        Criteria to plot. choice are ['max', 'min', 'mean', 'median', 'q20', 'q80']"
1346    figure: tuple
1347        input figure as (fig,ax) to add a new curve
1348    ax_settings: dict or class ax_properties
1349        object or dict with any attribute of class ax_properties
1350    fig_settings: dict or class ax_properties
1351        object or dict with any attribute of class fig_settings
1352    """
1353
1354    if isinstance(ax_settings, dict):
1355        default_ax_settings = ax_properties(
1356            ylabel=f"{stat} discharges (m3/s)",
1357            xlabel="Gauges stations",
1358            grid=True,
1359            legend=True,
1360            xticklabels_rotation=45,
1361            xtics_fontsize=6,
1362        )
1363        default_ax_settings.update(**ax_settings)
1364    else:
1365        default_ax_settings = ax_properties(**ax_settings.__dict__)
1366
1367    if isinstance(fig_settings, dict):
1368        fig_settings = fig_properties(**fig_settings)
1369    else:
1370        fig_settings = fig_properties(**fig_settings.__dict__)
1371
1372    if columns is not None:
1373        if values_sim is not None:
1374            values_sim = values_sim[columns]
1375
1376        if values_obs is not None:
1377            values_obs = values_obs[columns]
1378
1379        names = names[columns]
1380
1381    if np.all(values_obs == -99.0):
1382        values_obs = None
1383
1384    if values_sim is not None and values_obs is not None:
1385        if values_obs.size != values_sim.size:
1386            raise ValueError(
1387                "values_sim and values_obs must have the same size !"
1388            )
1389
1390    if figure is None:
1391        fig, ax = plt.subplots()
1392    else:
1393        fig, ax = figure
1394
1395    fig, ax = default_ax_settings.change(figure=(fig, ax))
1396
1397    x = np.arange(len(names))
1398    width = 0.25  # the width of the bars
1399
1400    multiplier = 0
1401
1402    if values_sim is not None:
1403        offset = width * multiplier
1404        ax.bar(x + offset, values_sim, width, label="obs")
1405        multiplier += 1
1406        # ax.bar_label(rects, padding=3)
1407
1408    if values_obs is not None:
1409        offset = width * multiplier
1410        ax.bar(x + offset, values_obs, width, label="sim")
1411        # ax.bar_label(rects, padding=3)
1412        # multiplier += 1
1413
1414    ax.set_xticks(x + width, names)
1415
1416    # bar_container = ax.bar(names, values, color="grey", tick_label=names)
1417
1418    # ax.bar_label(
1419    #     bar_container,
1420    #     fmt=lambda x: f"{x:.2f}",
1421    #     fontsize=default_ax_settings.barlabel_fontsize,
1422    # )
1423
1424    fig, ax = default_ax_settings.change(figure=(fig, ax))
1425    fig, ax = fig_settings.change(figure=(fig, ax))
1426
1427    return fig, ax
1428
1429
1430def plot_misfit_map(
1431    values: np.ndarray = [],
1432    names: np.ndarray = [],
1433    mesh=None,
1434    misfit: str = "nse",
1435    coef_hydro=99.0,
1436    catchment_polygon: None | DataFrame = None,
1437    ax_settings: dict | ax_properties = {},
1438    fig_settings: dict | fig_properties = {},
1439    plot_settings: dict | plot_properties = {},
1440):
1441    """
1442    Map plot of the misfit criteria between the simulated and observed discharges.
1443    Parameters:
1444    -----------
1445    values: np.ndarray
1446        The result of the discharge misfit for all outlets.
1447    names: np.ndarray
1448        Outlets name or code stored in an np.ndarray.
1449    mesh: None | dict
1450        The mesh of the Smash model as dict
1451    misfit: str
1452        Criteria to plot. choice are ['nse', 'nnse', 'rmse', 'nrmse', 'se', 'kge']"
1453    figure: tuple
1454        input figure as (fig,ax) to add a new curve
1455    ax_settings: dict or class ax_properties
1456        object or dict with any attribute of class ax_properties
1457    fig_settings: dict or class ax_properties
1458        object or dict with any attribute of class fig_settings
1459    plot_settings_sim: dict or class ax_properties
1460        object or dict with any attribute of class plot_settings.
1461    """
1462    if mesh is not None:
1463        if isinstance(mesh, dict):
1464            pass
1465        else:
1466            raise ValueError("mesh must be a dict")
1467    else:
1468        raise ValueError(
1469            "model or mesh are mandatory and must be a dict or a smash Model object"
1470        )
1471
1472    if isinstance(ax_settings, dict):
1473        default_ax_settings = ax_properties(
1474            title=f"Map of {misfit} criteria over the domain.",
1475            xlabel="x_coords",
1476            ylabel="y_coords",
1477            cmap="turbo_r",
1478        )
1479        default_ax_settings.update(**ax_settings)
1480    else:
1481        default_ax_settings = ax_properties(**ax_settings.__dict__)
1482
1483    if isinstance(fig_settings, dict):
1484        fig_settings = fig_properties(**fig_settings)
1485    else:
1486        fig_settings = fig_properties(**fig_settings.__dict__)
1487
1488    if isinstance(plot_settings, dict):
1489        default_plot_settings = plot_properties(
1490            marker="o",
1491            markersize=8,
1492        )
1493        default_plot_settings.update(**plot_settings)
1494    else:
1495        default_plot_settings = plot_properties(**plot_settings.__dict__)
1496
1497    # unset attribute color, managed separatly
1498    delattr(default_plot_settings, "color")
1499
1500    gauge = mesh["gauge_pos"]
1501    stations = mesh["code"]
1502    flow_acc = mesh["flwacc"]
1503    na = mesh["active_cell"] == 0
1504
1505    bbox = geo_toolbox.get_bbox_from_smash_mesh(mesh)
1506    extent = (bbox["left"], bbox["right"], bbox["bottom"], bbox["top"])
1507
1508    flow_accum_bv = np.where(na, 0.0, flow_acc.data)
1509    surfmin = (1.0 - coef_hydro / 100.0) * np.nanmax(flow_accum_bv)
1510    mask_flow = flow_accum_bv < surfmin
1511    flow_plot = np.where(mask_flow, np.nan, flow_accum_bv.data)
1512    flow_plot = np.where(na, np.nan, flow_plot)
1513
1514    plt.rcParams.update(plt.rcParamsDefault)
1515    fig, ax = plt.subplots()
1516    fig, ax = default_ax_settings.change(figure=(fig, ax))
1517
1518    active_cell = np.where(na, np.nan, mesh["active_cell"])
1519    cmap = ListedColormap(["lightgray"])
1520    ax.imshow(active_cell, cmap=cmap, extent=extent)
1521
1522    myblues = matplotlib.colormaps["binary"]
1523    cmp = ListedColormap(myblues(np.linspace(0.20, 1.0, 265)))
1524    im = ax.imshow(flow_plot, cmap=cmp, extent=extent)
1525
1526    if catchment_polygon is not None:
1527        # catchment_polygon = gpd.read_file(outlets_shapefile)
1528        catchment_polygon.plot(ax=ax, facecolor="none", edgecolor="black")
1529
1530    # create an axes on the right side of ax. The width of cax will be 5%
1531    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
1532    divider = make_axes_locatable(ax)
1533    cax = divider.append_axes("right", size="5%", pad=0.05)
1534
1535    fig.colorbar(
1536        im,
1537        cmap="Blues",
1538        ax=ax,
1539        label="Cumulated surface (km²)",
1540        shrink=0.75,
1541        cax=cax,
1542    )
1543
1544    # define bounds for the colormap
1545    if misfit == "nse" or misfit == "nnse":
1546        vmin = 0
1547        vmax = 1
1548    elif misfit == "rmse" or misfit == "nrmse" or misfit == "se":
1549        vmin = 0
1550        vmax = np.nanmax(values)
1551    else:
1552        vmin = np.nanmin(values)
1553        vmax = np.nanmax(values)
1554
1555    colormap = cm.get_cmap(default_ax_settings.cmap)
1556    cmp = ListedColormap(colormap(np.linspace(vmin, vmax, 256)))
1557
1558    ha = "right"
1559    for i in range(len(stations)):
1560
1561        if ha == "right":
1562            ha = "left"
1563            str_val = str(np.round(values[i], 2)).rjust(int(len(stations[i])))
1564            code = f"{stations[i]}\n {str_val}"
1565
1566        else:
1567            ha = "right"
1568            str_val = str(np.round(values[i], 2)).ljust(int(len(stations[i])))
1569            code = f"{stations[i]}\n {str_val}"
1570
1571        coord = geo_toolbox.rowcol_to_xy(
1572            gauge[i][0],
1573            gauge[i][1],
1574            mesh["xmin"],
1575            mesh["ymax"],
1576            mesh["xres"],
1577            mesh["yres"],
1578        )
1579
1580        ax.plot(
1581            coord[0],
1582            coord[1],
1583            color=cmp(values[i]),
1584            **default_plot_settings.__dict__,
1585        )
1586
1587        ax.annotate(
1588            code,  # this is the text
1589            # these are the coordinates to position the label
1590            (coord[0], coord[1]),
1591            textcoords="data",  # how to position the text
1592            xytext=(coord[0], coord[1]),  # distance from text to points (x,y)
1593            ha=ha,  # horizontal alignment can be left, right or center
1594            color=cmp(values[i]),
1595            fontsize=default_ax_settings.annotate_fontsize
1596            * default_ax_settings.font_ratio,
1597        )
1598
1599    import matplotlib as mpl
1600
1601    norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
1602    # create an axes on the right side of ax. The width of cax will be 5%
1603    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
1604    # divider = make_axes_locatable(ax)
1605    cax = divider.append_axes("right", size="5%", pad=0.5)
1606
1607    fig.colorbar(
1608        cm.ScalarMappable(norm=norm, cmap=cmp),
1609        cmap=cmp,
1610        ax=ax,
1611        cax=cax,
1612        label=misfit,
1613        shrink=0.75,
1614        location="right",
1615    )
1616
1617    fig, ax = default_ax_settings.change(figure=(fig, ax))
1618
1619    fig, ax = fig_settings.change(figure=(fig, ax))
1620
1621    return fig, ax
1622
1623
1624# def _ax_settings(
1625#     figure,
1626#     title: str = None,
1627#     xlabel: str = None,
1628#     ylabel: str = None,
1629#     clabel: str = None,
1630#     font_ratio: int = 1,
1631#     title_fontsize: int = 12,
1632#     label_fontsize: int = 10,
1633#     grid: bool = True,
1634#     xscale: str | None = None,
1635#     yscale: str | None = None,
1636#     legend: bool = True,
1637#     legend_loc: str = None,
1638#     legend_fontsize: int = 8,
1639#     xtics_fontsize: int = 8,
1640#     ytics_fontsize: int = 8,
1641#     cmap: str | None = None,
1642#     xlim: tuple | list | None = (None, None),
1643#     ylim: tuple | list | None = (None, None),
1644# ):
1645
1646#     fig, ax = figure
1647
1648#     plt.rcParams.update(plt.rcParamsDefault)
1649
1650#     if title is not None:
1651#         ax.set_title(title, fontsize=title_fontsize * font_ratio)
1652
1653#     if xlabel is not None:
1654#         ax.set_xlabel(xlabel)
1655
1656#     if ylabel is not None:
1657#         ax.set_ylabel(ylabel)
1658
1659#     if grid:
1660#         ax.grid(True, which="both", linestyle="--", alpha=0.5)
1661
1662#     if xscale is not None:
1663#         ax.set_xscale(xscale)
1664
1665#     if yscale is not None:
1666#         ax.set_xyscale(yscale)
1667
1668#     if legend:
1669#         ax.legend(loc=legend_loc)
1670
1671#     if cmap is not None:
1672#         plt.rc("image", cmap=cmap)
1673
1674#     if ylim[0] != None:
1675#         ax.set_ylim(bottom=ylim[0])
1676
1677#     if ylim[1] != None:
1678#         ax.set_ylim(top=ylim[1])
1679
1680#     if xlim[0] != None:
1681#         ax.set_xlim(left=xlim[0])
1682
1683#     if xlim[1] != None:
1684#         ax.set_xlim(right=xlim[1])
1685
1686#     plt.rcParams.update(
1687#         {
1688#             "axes.labelsize": label_fontsize * font_ratio,
1689#             "axes.titlesize": title_fontsize * font_ratio,
1690#             "legend.fontsize": legend_fontsize * font_ratio,
1691#             "figure.titlesize": title_fontsize * font_ratio,
1692#             "xtick.labelsize": xtics_fontsize * font_ratio,
1693#             "ytick.labelsize": ytics_fontsize * font_ratio,
1694#         }
1695#     )
1696
1697#     return fig, ax
1698
1699
1700# def _fig_settings(
1701#     figure,
1702#     figname=None,
1703#     xsize=8,
1704#     ysize=6,
1705#     transparent=False,
1706#     dpi=80,
1707#     font_ratio=1,
1708#     bbox_inches="tight",
1709# ):
1710
1711#     fig, ax = figure
1712
1713#     fig.set_figheight(ysize)
1714#     fig.set_figwidth(xsize)
1715
1716#     plt.rc(
1717#         "font", size=plt.rcParams["font.size"] * font_ratio
1718#     )  # controls default text sizes
1719#     plt.rc(
1720#         "axes", titlesize=plt.rcParams["axes.titlesize"] * font_ratio
1721#     )  # fontsize of the axes title
1722#     plt.rc(
1723#         "axes", labelsize=plt.rcParams["axes.labelsize"] * font_ratio
1724#     )  # fontsize of the x and y labels
1725#     plt.rc(
1726#         "xtick", labelsize=plt.rcParams["xtick.labelsize"] * font_ratio
1727#     )  # fontsize of the tick labels
1728#     plt.rc(
1729#         "ytick", labelsize=plt.rcParams["ytick.labelsize"] * font_ratio
1730#     )  # fontsize of the tick labels
1731#     plt.rc(
1732#         "legend", fontsize=plt.rcParams["legend.fontsize"] * font_ratio
1733#     )  # legend fontsize
1734#     plt.rc(
1735#         "figure", titlesize=plt.rcParams["figure.titlesize"] * font_ratio
1736#     )  # fontsize of the figure title
1737
1738#     if figname is not None:
1739#         fig.savefig(figname, transparent=transparent, dpi=dpi, bbox_inches=bbox_inches)
1740
1741#     return fig, ax