smashbox.plot.myplot API documentation

myplot(parent_class) View Source

16    def __init__(self, parent_class):
17        """
18        Initialisation.
19        :param parent_class: The parent class src.model.model() to be able to access to
20         the smash model
21        :type parent_class: src.model.model()
22        """
23        self._parent_class = parent_class
24        """The parent class src.model.model() to be able to access to the smash model"""

Initialisation.

Parameters

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): View Source

26    def plot_mesh(
27        self,
28        coef_hydro: float = 99.0,
29        ax_settings: dict = {},
30        fig_settings: dict = {},
31        html_show: bool = False,
32    ):
33        """
34        Plot the map of the mesh of the Smash model with teh outlets and the hydrographic
35        network.
36        :param coef_hydro: couloring cells where the surface is higher than `coef_hydro`%
37         of the total surface catchment, defaults to 99.0
38        :type coef_hydro: float, optional
39        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
40         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
41        :type ax_settings: dict, optional
42        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
43         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
44        :type fig_settings: dict, optional
45        :param html_show: Display the figure in an html page with your navigator, defaults
46         to False
47        :type html_show: bool, optional
48
49        """
50        default_ax_settings = plot.ax_properties(
51            title="Mesh of the Smash model",
52            xlabel="x_coords",
53            ylabel="y_coords",
54        )
55        default_ax_settings.update(**ax_settings)
56
57        fig_settings = plot.fig_properties(**fig_settings)
58
59        if not hasattr(self._parent_class.mymesh, "mesh"):
60            raise ValueError("No smash mesh found. Build the mesh first.")
61
62        fig, ax = plot.plot_mesh(
63            self._parent_class.mymesh.mesh,
64            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
65            coef_hydro=coef_hydro,
66            ax_settings=ax_settings,
67            fig_settings=fig_settings,
68        )
69
70        if fig_settings.figname is None:
71            if tools.with_reticulate() or html_show:
72                mpld3.show(fig, open_browser=True)
73            else:
74                fig.show()

Plot the map of the mesh of the Smash model with teh outlets and the hydrographic network.

Parameters

coef_hydro: couloring cells where the surface is higher than coef_hydro% of the total surface catchment, defaults to 99.0
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def plot_catchment_surface_consistency( self, label: bool = True, ax_settings: dict = {}, fig_settings: dict = {}, plot_settings: dict = {}, html_show: bool = False): View Source

 76    def plot_catchment_surface_consistency(
 77        self,
 78        label: bool = True,
 79        ax_settings: dict = {},
 80        fig_settings: dict = {},
 81        plot_settings: dict = {},
 82        html_show: bool = False,
 83    ):
 84        """
 85        Plot the modeled surface vs the observed surface. Check its consistency.
 86         :param label, labels the point on the plot with the code of the outlets.
 87         :type label: bool, default True
 88        :param ax_settings, any properties of plot.ax_properties() class can be defined
 89         in this dictionnary, defaults to {}
 90        :type ax_settings: dict, optional
 91        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
 92         plot.fig_properties() class can be defined in this dictionnary, defaults to {}
 93        :type fig_settings: dict, optional
 94        :param plot_settings,  any properties of plot.plot_properties() class can be
 95        defined in this dictionnary, defaults to {}
 96        :param html_show: Display the figure in an html page with your navigator, defaults
 97         to False
 98        :type html_show: bool, optional
 99
100        """
101
102        default_ax_settings = plot.ax_properties(
103            title="Modeled and observed surface consistency",
104            xlabel="Observed surface",
105            ylabel="Modeled surface",
106        )
107        default_ax_settings.update(**ax_settings)
108
109        fig_settings = plot.fig_properties(**fig_settings)
110
111        if not hasattr(self._parent_class.mymesh, "mesh"):
112            raise ValueError("No smash mesh found. Build the mesh first.")
113
114        fig, ax = plot.plot_catchment_surface_consistency(
115            mesh=self._parent_class.mymesh.mesh,
116            label=label,
117            ax_settings=ax_settings,
118            fig_settings=fig_settings,
119            plot_settings=plot_settings,
120        )
121
122        if fig_settings.figname is None:
123            if tools.with_reticulate() or html_show:
124                mpld3.show(fig, open_browser=True)
125            else:
126                fig.show()

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 {}

Parameters

fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class can be defined in this dictionnary, defaults to {} :param plot_settings, any properties of plot.plot_properties() class can be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def plot_catchment_surface_error( self, ax_settings: dict = {}, fig_settings: dict = {}, html_show: bool = False): View Source

128    def plot_catchment_surface_error(
129        self,
130        ax_settings: dict = {},
131        fig_settings: dict = {},
132        html_show: bool = False,
133    ):
134        """
135        Plot the modeled surface vs the observed surface. Check its consistency.
136         :param ax_settings, any properties of plot.ax_properties() class can be defined
137         in this dictionnary, defaults to {}
138        :type ax_settings: dict, optional
139        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
140         plot.fig_properties() class can be defined in this dictionnary, defaults to {}
141        :param html_show: Display the figure in an html page with your navigator, defaults
142         to False
143        :type html_show: bool, optional
144
145        """
146
147        default_ax_settings = plot.ax_properties(
148            title="Catchment surface error",
149            xlabel="Catchments",
150            ylabel="(Ssim - Sobs)/Sobs",
151        )
152        default_ax_settings.update(**ax_settings)
153
154        fig_settings = plot.fig_properties(**fig_settings)
155
156        if not hasattr(self._parent_class.mymesh, "mesh"):
157            raise ValueError("No smash mesh found. Build the mesh first.")
158
159        fig, ax = plot.plot_catchment_surface_error(
160            mesh=self._parent_class.mymesh.mesh,
161            ax_settings=ax_settings,
162            fig_settings=fig_settings,
163        )
164
165        if fig_settings.figname is None:
166            if tools.with_reticulate() or html_show:
167                mpld3.show(fig, open_browser=True)
168            else:
169                fig.show()

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 {}

Parameters

fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class can be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def plot_xy_quantile(*args, **kwargs): View Source

 95    def wrapper(*args, **kwargs):
 96
 97        bound = sig.bind(*args, **kwargs)
 98        bound.apply_defaults()
 99
100        for name, value in bound.arguments.items():
101            if name in annotations:
102
103                target_type = annotations[name]
104
105                args_ = get_args(target_type)
106
107                if target_type is None and len(args_) == 0:
108                    args_ = (type(None),)
109                    target_type = type(None)
110
111                if not type(value) in args_:
112
113                    if len(args_) > 1 and type(None) in args_:
114
115                        converted = False
116                        for t in args_:
117
118                            if t is not type(None):
119
120                                if value is not None:
121                                    try:
122                                        print(
123                                            f"</> Warning: Arg '{name}' of type {type(value)} is being"
124                                            f" converted to {t}"
125                                        )
126                                        bound.arguments[name] = t(value)
127                                        converted = True
128                                    except:
129                                        pass
130
131                                if converted:
132                                    break
133
134                        if not converted:
135                            raise TypeError(
136                                f"</> Error: Arg '{name}' must be a type of "
137                                f" {args_}, got {value}"
138                                f" ({type(value).__name__})"
139                            )
140
141                    else:
142                        if not isinstance(value, target_type):
143                            try:
144                                print(
145                                    f"</> Warning: Arg '{name}' of type {type(value)} is being"
146                                    f" converted to {target_type}"
147                                )
148                                bound.arguments[name] = target_type(value)
149                            except Exception:
150                                raise TypeError(
151                                    f"</> Error: Arg '{name}' must be a type of "
152                                    f" {target_type.__name__}, got {value}"
153                                    f" ({type(value).__name__})"
154                                )
155
156        return func(*bound.args, **bound.kwargs)

Parameters

duration: Duration of the quantile, defaults to 1
X: X coordinate of the targeted cell (matrix coordinate system), defaults to 0
Y: Y coordinate of the targeted cell (matrix coordinate system), defaults to 0
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def plot_outlets_quantile(*args, **kwargs): View Source

 95    def wrapper(*args, **kwargs):
 96
 97        bound = sig.bind(*args, **kwargs)
 98        bound.apply_defaults()
 99
100        for name, value in bound.arguments.items():
101            if name in annotations:
102
103                target_type = annotations[name]
104
105                args_ = get_args(target_type)
106
107                if target_type is None and len(args_) == 0:
108                    args_ = (type(None),)
109                    target_type = type(None)
110
111                if not type(value) in args_:
112
113                    if len(args_) > 1 and type(None) in args_:
114
115                        converted = False
116                        for t in args_:
117
118                            if t is not type(None):
119
120                                if value is not None:
121                                    try:
122                                        print(
123                                            f"</> Warning: Arg '{name}' of type {type(value)} is being"
124                                            f" converted to {t}"
125                                        )
126                                        bound.arguments[name] = t(value)
127                                        converted = True
128                                    except:
129                                        pass
130
131                                if converted:
132                                    break
133
134                        if not converted:
135                            raise TypeError(
136                                f"</> Error: Arg '{name}' must be a type of "
137                                f" {args_}, got {value}"
138                                f" ({type(value).__name__})"
139                            )
140
141                    else:
142                        if not isinstance(value, target_type):
143                            try:
144                                print(
145                                    f"</> Warning: Arg '{name}' of type {type(value)} is being"
146                                    f" converted to {target_type}"
147                                )
148                                bound.arguments[name] = target_type(value)
149                            except Exception:
150                                raise TypeError(
151                                    f"</> Error: Arg '{name}' must be a type of "
152                                    f" {target_type.__name__}, got {value}"
153                                    f" ({type(value).__name__})"
154                                )
155
156        return func(*bound.args, **bound.kwargs)

Plot the quantiles prediction for different return period for every outlets.

Parameters

duration: Duration of the quantile, defaults to 1
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.
gauge: List of gauge code to plot. Default is None. If None all gague are plotted
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
plot_settings: Parameters of the matplotlib figure 'fig'. Any properties of plot.plot_settings() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def plot_spatial_quantile(*args, **kwargs): View Source

 95    def wrapper(*args, **kwargs):
 96
 97        bound = sig.bind(*args, **kwargs)
 98        bound.apply_defaults()
 99
100        for name, value in bound.arguments.items():
101            if name in annotations:
102
103                target_type = annotations[name]
104
105                args_ = get_args(target_type)
106
107                if target_type is None and len(args_) == 0:
108                    args_ = (type(None),)
109                    target_type = type(None)
110
111                if not type(value) in args_:
112
113                    if len(args_) > 1 and type(None) in args_:
114
115                        converted = False
116                        for t in args_:
117
118                            if t is not type(None):
119
120                                if value is not None:
121                                    try:
122                                        print(
123                                            f"</> Warning: Arg '{name}' of type {type(value)} is being"
124                                            f" converted to {t}"
125                                        )
126                                        bound.arguments[name] = t(value)
127                                        converted = True
128                                    except:
129                                        pass
130
131                                if converted:
132                                    break
133
134                        if not converted:
135                            raise TypeError(
136                                f"</> Error: Arg '{name}' must be a type of "
137                                f" {args_}, got {value}"
138                                f" ({type(value).__name__})"
139                            )
140
141                    else:
142                        if not isinstance(value, target_type):
143                            try:
144                                print(
145                                    f"</> Warning: Arg '{name}' of type {type(value)} is being"
146                                    f" converted to {target_type}"
147                                )
148                                bound.arguments[name] = target_type(value)
149                            except Exception:
150                                raise TypeError(
151                                    f"</> Error: Arg '{name}' must be a type of "
152                                    f" {target_type.__name__}, got {value}"
153                                    f" ({type(value).__name__})"
154                                )
155
156        return func(*bound.args, **bound.kwargs)

Plot the map of the quantiles for given return period and a given duration.

Parameters

duration: Duration of the quantile, defaults to 1
T: return period, defaults to 2 (default is years, but that depends of the chunk size)
vmin: Minimal bounds value for the colorbar, defaults to 0
vmax: Maximal bounds value for the colorbar, defaults to None
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def multiplot_spatial_quantile(*args, **kwargs): View Source

 95    def wrapper(*args, **kwargs):
 96
 97        bound = sig.bind(*args, **kwargs)
 98        bound.apply_defaults()
 99
100        for name, value in bound.arguments.items():
101            if name in annotations:
102
103                target_type = annotations[name]
104
105                args_ = get_args(target_type)
106
107                if target_type is None and len(args_) == 0:
108                    args_ = (type(None),)
109                    target_type = type(None)
110
111                if not type(value) in args_:
112
113                    if len(args_) > 1 and type(None) in args_:
114
115                        converted = False
116                        for t in args_:
117
118                            if t is not type(None):
119
120                                if value is not None:
121                                    try:
122                                        print(
123                                            f"</> Warning: Arg '{name}' of type {type(value)} is being"
124                                            f" converted to {t}"
125                                        )
126                                        bound.arguments[name] = t(value)
127                                        converted = True
128                                    except:
129                                        pass
130
131                                if converted:
132                                    break
133
134                        if not converted:
135                            raise TypeError(
136                                f"</> Error: Arg '{name}' must be a type of "
137                                f" {args_}, got {value}"
138                                f" ({type(value).__name__})"
139                            )
140
141                    else:
142                        if not isinstance(value, target_type):
143                            try:
144                                print(
145                                    f"</> Warning: Arg '{name}' of type {type(value)} is being"
146                                    f" converted to {target_type}"
147                                )
148                                bound.arguments[name] = target_type(value)
149                            except Exception:
150                                raise TypeError(
151                                    f"</> Error: Arg '{name}' must be a type of "
152                                    f" {target_type.__name__}, got {value}"
153                                    f" ({type(value).__name__})"
154                                )
155
156        return func(*bound.args, **bound.kwargs)

Plot the map of the quantiles for every return period for a given duration.

Parameters

duration: Duration of the quantile, defaults to 1
vmin: Minimal bounds value for the colorbar, defaults to 0
vmax: Maximal bounds value for the colorbar, defaults to None
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

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): View Source

551    def plot_spatial_stats(
552        self,
553        stats: str = "max",
554        vmin: float | None = 0,
555        vmax: float | None = None,
556        ax_settings: dict = {},
557        fig_settings: dict = {},
558        html_show: bool = False,
559    ):
560        """
561        Plot the map of a given spatial statistic.
562        :param stats: The statistic to plot, choice are
563         'max, min, mean, median, q20, q80', defaults to "max"
564        :type stats: str, optional
565        ::param vmin: Minimal bounds value for the colorbar, defaults to 0
566        :type vmin: float, optional
567        :param vmax: Maximal bounds value for the colorbar, defaults to None
568        :type vmax: float, optional
569        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
570         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
571        :type ax_settings: dict, optional
572        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
573         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
574        :type fig_settings: dict, optional
575        :param html_show: Display the figure in an html page with your navigator, defaults
576         to False
577        :type html_show: bool, optional
578
579        """
580
581        fig_settings = plot.fig_properties(**fig_settings)
582
583        if not hasattr(self._parent_class.mystats.spatial_stats.results, stats):
584            raise ValueError(
585                f"Statistical results `{stats}` not found. Choice are: "
586                "[min, max, mean, median, q20, q80]"
587            )
588
589        stats_matrix = getattr(
590            self._parent_class.mystats.spatial_stats.results,
591            stats,
592        )
593        default_ax_settings = plot.ax_properties(
594            title="Maximal Discharges on periode"
595            f" {self._parent_class.mysmashmodel.setup.start_time} -"
596            f" {self._parent_class.mysmashmodel.setup.end_time}",
597            xlabel="Coords X",
598            ylabel="Coords_Y",
599            clabel="Discharge (m^3/s)",
600            cmap="viridis",
601        )
602        default_ax_settings.update(**ax_settings)
603
604        fig, ax = plot.plot_image(
605            matrice=stats_matrix,
606            bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
607            vmin=vmin,
608            vmax=vmax,
609            mask=self._parent_class.mysmashmodel.mesh.active_cell,
610            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
611            ax_settings=default_ax_settings,
612            fig_settings=fig_settings,
613        )
614
615        if fig_settings.figname is None:
616            if tools.with_reticulate() or html_show:
617                mpld3.show(fig, open_browser=True)
618            else:
619                fig.show()
620
621        # return fig, ax

Plot the map of a given spatial statistic.

Parameters

stats: The statistic to plot, choice are 'max, min, mean, median, q20, q80', defaults to "max" ::param vmin: Minimal bounds value for the colorbar, defaults to 0
vmax: Maximal bounds value for the colorbar, defaults to None
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

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): View Source

623    def plot_hydrograph(
624        self,
625        columns: list | None = [],
626        outlets_name: list = [],
627        plot_rainfall: bool = True,
628        ax_settings: dict = {},
629        fig_settings: dict = {},
630        plot_settings_sim: dict = {},
631        plot_settings_obs: dict = {},
632        html_show: bool = False,
633    ):
634        """
635        Plot the simulated and the observed hydrogram for different outlets.
636
637        :param columns: Columns of the matrix to plot (outlets), defaults to []
638        :type columns: list | None, optional
639        :param outlets_name: List of the outlets name to plot, defaults to []
640        :type outlets_name: list, optional
641        :param plot_rainfall: Plot the rainfall on the graphics, defaults to True
642        :type plot_rainfall: bool, optional
643        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
644         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
645        :type ax_settings: dict, optional
646        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
647         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
648        :type fig_settings: dict, optional
649        :param plot_settings_sim: Parameters of the matplotlib curves. Any propoerties of
650         plot.plot_properties() class ca be defined in this dictionnary, defaults to {}
651        :type plot_settings_sim: dict, optional
652        :param plot_settings_obs: DParameters of the matplotlib curves. Any propoerties of
653         plot.plot_properties() class ca be defined in this dictionnary, defaults to {}
654        :type plot_settings_obs: dict, optional
655        :pparam html_show: Display the figure in an html page with your navigator, defaults
656         to False
657        :type html_show: bool, optional
658
659        """
660
661        fig_settings = plot.fig_properties(**fig_settings)
662
663        if len(outlets_name) > 0:
664            columns = tools.array_isin(
665                self._parent_class.mysmashmodel.mesh.code,
666                np.array(outlets_name),
667            )
668        elif len(columns) > 0:
669            outlets_name = [self._parent_class.mysmashmodel.mesh.code[i] for i in columns]
670
671        if columns is None:
672            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
673            outlets_name = list(self._parent_class.mysmashmodel.mesh.code)
674
675        if len(columns) == 0:
676            columns = [0]
677            outlets_name = [list(self._parent_class.mysmashmodel.mesh.code)[0]]
678
679        fig, ax = plot.plot_hydrograph(
680            model=self._parent_class.mysmashmodel,
681            columns=columns,
682            outlets_name=outlets_name,
683            plot_rainfall=plot_rainfall,
684            ax_settings=ax_settings,
685            fig_settings=fig_settings,
686            plot_settings_sim=plot_settings_sim,
687            plot_settings_obs=plot_settings_obs,
688        )
689
690        if fig_settings.figname is None:
691            if tools.with_reticulate() or html_show:
692                mpld3.show(fig, open_browser=True)
693            else:
694                fig.show()
695
696        # return fig, ax

Plot the simulated and the observed hydrogram for different outlets.

Parameters

columns: Columns of the matrix to plot (outlets), defaults to []
outlets_name: List of the outlets name to plot, defaults to []
plot_rainfall: Plot the rainfall on the graphics, defaults to True
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
plot_settings_sim: Parameters of the matplotlib curves. Any propoerties of plot.plot_properties() class ca be defined in this dictionnary, defaults to {}
plot_settings_obs: DParameters of the matplotlib curves. Any propoerties of plot.plot_properties() class ca be defined in this dictionnary, defaults to {} :pparam html_show: Display the figure in an html page with your navigator, defaults to False

def plot_misfit( self, columns: list | None = None, outlets_name: list = [], misfit: str = 'nse', ax_settings: dict = {}, fig_settings: dict = {}, html_show: bool = False): View Source

698    def plot_misfit(
699        self,
700        columns: list | None = None,
701        outlets_name: list = [],
702        misfit: str = "nse",
703        ax_settings: dict = {},
704        fig_settings: dict = {},
705        html_show: bool = False,
706    ):
707        """
708        Plot a misfit criteria for a given list of outlet.
709        :param columns: Columns of the matrix to plot (outlets), defaults to []
710        :type columns: list | None, optional
711        :param outlets_name: List of the outlets name to plot, defaults to []
712        :type outlets_name: list, optional
713        :param misfit: The misfit criteria to plot, choice are
714        "nse, nnse, rmse, nrmse, se, kge", defaults to "nse"
715        :type misfit: str, optional
716        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
717         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
718        :type ax_settings: dict, optional
719        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
720         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
721        :type fig_settings: dict, optional
722        :param html_show: Display the figure in an html page with your navigator, defaults
723         to False
724        :type html_show: bool, optional
725
726        """
727
728        fig_settings = plot.fig_properties(**fig_settings)
729
730        values = getattr(self._parent_class.mystats.misfit_stats.results, misfit)
731
732        if len(outlets_name) > 0:
733            columns = tools.array_isin(
734                self._parent_class.mysmashmodel.mesh.code,
735                np.array(outlets_name),
736            )
737
738        if columns is None:
739            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
740            outlets_name = self._parent_class.mysmashmodel.mesh.code
741
742        fig, ax = plot.plot_misfit(
743            values=values[columns],
744            names=outlets_name,
745            columns=None,
746            misfit=misfit,
747            ax_settings=ax_settings,
748            fig_settings=fig_settings,
749        )
750
751        if fig_settings.figname is None:
752            if tools.with_reticulate() or html_show:
753                mpld3.show(fig, open_browser=True)
754            else:
755                fig.show()
756
757        # return fig, ax

Plot a misfit criteria for a given list of outlet.

Parameters

columns: Columns of the matrix to plot (outlets), defaults to []
outlets_name: List of the outlets name to plot, defaults to []
misfit: The misfit criteria to plot, choice are "nse, nnse, rmse, nrmse, se, kge", defaults to "nse"
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

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): View Source

759    def plot_outlet_stats(
760        self,
761        columns: list | None = None,
762        outlets_name: list = [],
763        stat: str = "max",
764        ax_settings: dict = {},
765        fig_settings: dict = {},
766        html_show: bool = False,
767    ):
768        """
769        Plot a statistical criteria for a given list of outlet.
770        :param columns: Columns of the matrix to plot (outlets), defaults to []
771        :type columns: list | None, optional
772        :param outlets_name: List of the outlets name to plot, defaults to []
773        :type outlets_name: list, optional
774        :param misfit: The misfit criteria to plot, choice are
775        "nse, nnse, rmse, nrmse, se, kge", defaults to "nse"
776        :type misfit: str, optional
777        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
778         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
779        :type ax_settings: dict, optional
780        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
781         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
782        :type fig_settings: dict, optional
783        :param html_show: Display the figure in an html page with your navigator, defaults
784         to False
785        :type html_show: bool, optional
786
787        """
788
789        fig_settings = plot.fig_properties(**fig_settings)
790
791        values_sim = getattr(self._parent_class.mystats.outlets_stats.results_sim, stat)
792        values_obs = getattr(self._parent_class.mystats.outlets_stats.results_obs, stat)
793
794        if len(outlets_name) > 0:
795            columns = tools.array_isin(
796                self._parent_class.mysmashmodel.mesh.code,
797                np.array(outlets_name),
798            )
799
800        if columns is None:
801            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
802            outlets_name = list(self._parent_class.mysmashmodel.mesh.code)
803
804        fig, ax = plot.plot_outlet_stats(
805            values_sim=values_sim[columns],
806            values_obs=values_obs[columns],
807            names=outlets_name,
808            columns=None,
809            stat=stat,
810            ax_settings=ax_settings,
811            fig_settings=fig_settings,
812        )
813
814        if fig_settings.figname is None:
815            if tools.with_reticulate() or html_show:
816                mpld3.show(fig, open_browser=True)
817            else:
818                fig.show()
819
820        # return fig, ax

Plot a statistical criteria for a given list of outlet.

Parameters

columns: Columns of the matrix to plot (outlets), defaults to []
outlets_name: List of the outlets name to plot, defaults to []
misfit: The misfit criteria to plot, choice are "nse, nnse, rmse, nrmse, se, kge", defaults to "nse"
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

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): View Source

822    def multiplot_misfit(
823        self,
824        columns: list | None = None,
825        outlets_name: list = [],
826        misfit: list = [
827            "nse",
828            "nnse",
829            "kge",
830            "mse",
831            "rmse",
832            "nrmse",
833            "se",
834            "mae",
835            "mape",
836            "lgrm",
837        ],
838        ax_settings: dict = {},
839        fig_settings: dict = {},
840        html_show: bool = False,
841    ):
842        """
843        Plot misfit criterium for a given list of outlets.
844
845        :param columns: Columns of the matrix to plot (outlets), defaults to []
846        :type columns: list | None, optional
847        :param outlets_name: List of the outlets name to plot, defaults to []
848        :type outlets_name: list, optional
849        :param misfit: The misfit criteria to plot, list of criteria among
850        "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
851        :type misfit: str, optional
852        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
853         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
854        :type ax_settings: dict, optional
855        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
856         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
857        :type fig_settings: dict, optional
858        :param html_show: Display the figure in an html page with your navigator, defaults
859         to False
860        :type html_show: bool, optional
861
862        """
863
864        fig_settings = plot.fig_properties(**fig_settings)
865
866        if len(outlets_name) > 0:
867            columns = tools.array_isin(
868                self._parent_class.mysmashmodel.mesh.code,
869                np.array(outlets_name),
870            )
871
872        if columns is None:
873            columns = list(range(0, self._parent_class.mysmashmodel.response.q.shape[0]))
874            outlets_name = list(self._parent_class.mysmashmodel.mesh.code)
875
876        yfig = int(np.sqrt(len(misfit)))
877        xfig = int(np.ceil(len(misfit) / yfig))
878
879        fig, axs = plt.subplots(
880            xfig,
881            yfig,
882            constrained_layout=True,
883        )
884
885        # for ax in axs:
886        #     ax.set_axis_off()
887
888        for ax, crit in zip(
889            axs.flat,
890            misfit,
891        ):
892
893            # ax.set_axis_on()
894            ax_settings["ylabel"] = f"{crit} criteria"
895            ax_settings["title"] = f"{crit} criteria"
896
897            if hasattr(self._parent_class.mystats.misfit_stats.results, crit):
898                values = getattr(self._parent_class.mystats.misfit_stats.results, crit)
899            else:
900                raise ValueError(
901                    f"`{crit}` is not a valid statistic. choice are:"
902                    "[nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge]"
903                )
904
905            fig, ax = plot.plot_misfit(
906                values=values[columns],
907                names=np.array(outlets_name),
908                columns=None,
909                misfit=crit,
910                figure=(fig, ax),
911                ax_settings=ax_settings,
912            )
913
914        [fig.delaxes(ax) for ax in axs.flatten() if not ax.has_data()]
915        fig_settings.change((fig, ax))
916
917        if fig_settings.figname is None:
918            if tools.with_reticulate() or html_show:
919                mpld3.show(fig, open_browser=True)
920            else:
921                fig.show()
922
923        # return fig, ax

Plot misfit criterium for a given list of outlets.

Parameters

columns: Columns of the matrix to plot (outlets), defaults to []
outlets_name: List of the outlets name to plot, defaults to []
misfit: The misfit criteria to plot, list of criteria among "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

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): View Source

925    def plot_misfit_map(
926        self,
927        misfit: str = "nse",
928        coef_hydro: float = 99.0,
929        ax_settings: dict = {},
930        fig_settings: dict = {},
931        plot_settings: dict = {},
932        html_show: bool = False,
933    ):
934        """
935        Plot a map of a misfit criteria.
936
937        :param columns: Columns of the matrix to plot (outlets), defaults to []
938        :type columns: list | None, optional
939        :param outlets_name: List of the outlets name to plot, defaults to []
940        :type outlets_name: list, optional
941        :param misfit: The misfit criteria to plot, choice are
942        "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
943        :type misfit: str, optional
944        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
945         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
946        :type ax_settings: dict, optional
947        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
948         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
949        :type fig_settings: dict, optional
950        :param html_show: Display the figure in an html page with your navigator, defaults
951         to False
952        :type html_show: bool, optional
953
954        """
955
956        if hasattr(self._parent_class.mystats.misfit_stats.results, misfit):
957            values = getattr(self._parent_class.mystats.misfit_stats.results, misfit)
958        else:
959            raise ValueError(
960                f"`{misfit}` is not a valid statistic. choice are:"
961                "[nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge]"
962            )
963
964        fig_settings = plot.fig_properties(**fig_settings)
965
966        name = self._parent_class.mysmashmodel.mesh.code
967        mesh = self._parent_class.mymesh.mesh
968
969        fig, ax = plot.plot_misfit_map(
970            values=values,
971            names=name,
972            mesh=mesh,
973            misfit=misfit,
974            coef_hydro=coef_hydro,
975            ax_settings=ax_settings,
976            fig_settings=fig_settings,
977            plot_settings=plot_settings,
978        )
979
980        if fig_settings.figname is None:
981            if tools.with_reticulate() or html_show:
982                mpld3.show(fig, open_browser=True)
983            else:
984                fig.show()
985
986        # return fig, ax

Plot a map of a misfit criteria.

Parameters

columns: Columns of the matrix to plot (outlets), defaults to []
outlets_name: List of the outlets name to plot, defaults to []
misfit: The misfit criteria to plot, choice are "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def multiplot_parameters( self, mask_active_cell=False, ax_settings={}, fig_settings={}, html_show: bool = False): View Source

 988    def multiplot_parameters(
 989        self,
 990        mask_active_cell=False,
 991        ax_settings={},
 992        fig_settings={},
 993        html_show: bool = False,
 994    ):
 995        """
 996        Multiplot map of every Smash parameters
 997        :param mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
 998        :type mask_active_cell: bool, False, optional
 999        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
1000         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
1001        :type ax_settings: dict, optional
1002        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
1003         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
1004        :type fig_settings: dict, optional
1005        :param html_show: Display the figure in an html page with your navigator, defaults
1006         to False
1007        :type html_show: bool, optional
1008
1009        """
1010
1011        default_fig_settings = plot.fig_properties(xsize=8, ysize=8)
1012        default_fig_settings.update(**fig_settings)
1013
1014        param = list(self._parent_class.mysmashmodel.rr_parameters.keys)
1015
1016        if mask_active_cell:
1017            mask = self._parent_class.mysmashmodel.mesh.active_cell
1018        else:
1019            mask = None
1020
1021        yfig = int(np.sqrt(len(param)))
1022        xfig = int(np.ceil(len(param) / yfig))
1023
1024        fig, axs = plt.subplots(
1025            xfig,
1026            yfig,
1027            constrained_layout=False,
1028        )
1029        plt.subplots_adjust(
1030            left=None, bottom=None, right=None, top=None, wspace=0.5, hspace=0.5
1031        )
1032        for ax, p in zip(axs.flat, param):
1033
1034            default_ax_settings = plot.ax_properties(
1035                title=f"{p} parameters map",
1036                xlabel="Coords X",
1037                ylabel="Coords_Y",
1038                clabel=f"{p} parameter value",
1039                cmap="viridis",
1040            )
1041            default_ax_settings.update(**ax_settings)
1042
1043            z = param.index(p)
1044
1045            fig, ax = plot.plot_image(
1046                matrice=self._parent_class.mysmashmodel.rr_parameters.values[:, :, z],
1047                bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
1048                mask=mask,
1049                vmin=0.0,
1050                catchment_polygon=self._parent_class.mymesh.catchment_polygon,
1051                ax_settings=default_ax_settings,
1052                figure=[fig, ax],
1053            )
1054
1055        [fig.delaxes(ax) for ax in axs.flatten() if not ax.has_data()]
1056        default_fig_settings.change((fig, axs))
1057
1058        if default_fig_settings.figname is None or html_show:
1059            if tools.with_reticulate():
1060                mpld3.show(fig, open_browser=True)
1061            else:
1062                fig.show()
1063
1064        # return fig, axs

Multiplot map of every Smash parameters

Parameters

mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False

def plot_parameters( self, param='cp', mask_active_cell=False, vmin=0.0, vmax=None, ax_settings={}, fig_settings={}, html_show: bool = False): View Source

1066    def plot_parameters(
1067        self,
1068        param="cp",
1069        mask_active_cell=False,
1070        vmin=0.0,
1071        vmax=None,
1072        ax_settings={},
1073        fig_settings={},
1074        html_show: bool = False,
1075    ):
1076        """
1077        Plot a map of a Smash parameters
1078        :param param: Name of the parameter to plot, defaults to "cp"
1079        :type param: str, optional
1080        :param mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
1081        :type mask_active_cell: bool, False, optional
1082        :param vmin: Minimum value of the colorbar, defaults to 0.0
1083        :type vmin: float, optional
1084        :param vmax: Maximum value of the colorbar, defaults to None
1085        :type vmax: float, optional
1086        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
1087         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
1088        :type ax_settings: dict, optional
1089        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
1090         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
1091        :type fig_settings: dict, optional
1092        :param html_show: Display the figure in an html page with your navigator, defaults
1093         to False
1094        :type html_show: bool, optional
1095        """
1096
1097        fig_settings = plot.fig_properties(**fig_settings)
1098
1099        list_param = list(self._parent_class.mysmashmodel.rr_parameters.keys)
1100        z = list_param.index(param)
1101
1102        if mask_active_cell:
1103            mask = self._parent_class.mysmashmodel.mesh.active_cell
1104        else:
1105            mask = None
1106
1107        fig, axs = plt.subplots()
1108
1109        default_ax_settings = plot.ax_properties(
1110            title=f"{param} parameters map",
1111            xlabel="Coords X",
1112            ylabel="Coords_Y",
1113            clabel=f"{param} parameter value",
1114            cmap="viridis",
1115        )
1116        default_ax_settings.update(**ax_settings)
1117
1118        fig, ax = plot.plot_image(
1119            matrice=self._parent_class.mysmashmodel.rr_parameters.values[:, :, z],
1120            bbox=geo_toolbox.get_bbox_from_smash_mesh(self._parent_class.mymesh.mesh),
1121            mask=mask,
1122            vmin=vmin,
1123            vmax=vmax,
1124            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
1125            ax_settings=default_ax_settings,
1126        )
1127
1128        fig_settings.change((fig, axs))
1129
1130        if fig_settings.figname is None or html_show:
1131            if tools.with_reticulate():
1132                mpld3.show(fig, open_browser=True)
1133            else:
1134                fig.show()
1135
1136        # return fig, axs

Plot a map of a Smash parameters

Parameters

param: Name of the parameter to plot, defaults to "cp"
mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
vmin: Minimum value of the colorbar, defaults to 0.0
vmax: Maximum value of the colorbar, defaults to None
ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
html_show: Display the figure in an html page with your navigator, defaults to False