smashbox.plot.myplot API documentation

myplot(parent_class) View Source

18    def __init__(self, parent_class):
19        """
20        Initialisation.
21        :param parent_class: The parent class src.model.model() to be able to access to
22         the smash model
23        :type parent_class: src.model.model()
24        """
25        self._parent_class = parent_class
26        """The parent class src.model.model() to be able to access to the smash model"""
27
28        self._target = "mysmashmodel"
29        """The target to plot. Default is mysmashmodel"""
30
31        self._plot_object = getattr(self._parent_class, self._target)
32        """The target object to plot. Default is mysmashmodel"""

Initialisation.

Parameters

parent_class: The parent class src.model.model() to be able to access to the smash model

target View Source

34    @property
35    def target(self):
36        """Property: The target object to plot. Default is mysmashmodel"""
37        return self._target

Property: The target object to plot. Default is mysmashmodel

def plot_mesh( self, coef_hydro: float = 99.0, ax_settings: dict = {}, fig_settings: dict = {}, html_show: bool = False): View Source

 60    def plot_mesh(
 61        self,
 62        coef_hydro: float = 99.0,
 63        ax_settings: dict = {},
 64        fig_settings: dict = {},
 65        html_show: bool = False,
 66    ):
 67        """
 68        Plot the map of the mesh of the Smash model with teh outlets and the hydrographic
 69        network.
 70        :param coef_hydro: couloring cells where the surface is higher than `coef_hydro`%
 71         of the total surface catchment, defaults to 99.0
 72        :type coef_hydro: float, optional
 73        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
 74         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
 75        :type ax_settings: dict, optional
 76        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
 77         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
 78        :type fig_settings: dict, optional
 79        :param html_show: Display the figure in an html page with your navigator, defaults
 80         to False
 81        :type html_show: bool, optional
 82
 83        """
 84        default_ax_settings = plot.ax_properties(
 85            title="Mesh of the Smash model",
 86            xlabel="x_coords",
 87            ylabel="y_coords",
 88        )
 89        default_ax_settings.update(**ax_settings)
 90
 91        fig_settings = plot.fig_properties(**fig_settings)
 92
 93        if not hasattr(self._parent_class.mymesh, "mesh"):
 94            raise ValueError("No smash mesh found. Build the mesh first.")
 95
 96        fig, ax = plot.plot_mesh(
 97            self._parent_class.mymesh.mesh,
 98            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
 99            coef_hydro=coef_hydro,
100            ax_settings=ax_settings,
101            fig_settings=fig_settings,
102        )
103
104        if fig_settings.figname is None:
105            if tools.with_reticulate() or html_show:
106                mpld3.show(fig, open_browser=True)
107            else:
108                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

110    def plot_catchment_surface_consistency(
111        self,
112        label: bool = True,
113        ax_settings: dict = {},
114        fig_settings: dict = {},
115        plot_settings: dict = {},
116        html_show: bool = False,
117    ):
118        """
119        Plot the modeled surface vs the observed surface. Check its consistency.
120         :param label, labels the point on the plot with the code of the outlets.
121         :type label: bool, default True
122        :param ax_settings, any properties of plot.ax_properties() class can be defined
123         in this dictionnary, defaults to {}
124        :type ax_settings: dict, optional
125        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
126         plot.fig_properties() class can be defined in this dictionnary, defaults to {}
127        :type fig_settings: dict, optional
128        :param plot_settings,  any properties of plot.plot_properties() class can be
129        defined in this dictionnary, defaults to {}
130        :param html_show: Display the figure in an html page with your navigator, defaults
131         to False
132        :type html_show: bool, optional
133
134        """
135
136        default_ax_settings = plot.ax_properties(
137            title="Modeled and observed surface consistency",
138            xlabel="Observed surface",
139            ylabel="Modeled surface",
140        )
141        default_ax_settings.update(**ax_settings)
142
143        fig_settings = plot.fig_properties(**fig_settings)
144
145        if not hasattr(self._parent_class.mymesh, "mesh"):
146            raise ValueError("No smash mesh found. Build the mesh first.")
147
148        fig, ax = plot.plot_catchment_surface_consistency(
149            mesh=self._parent_class.mymesh.mesh,
150            label=label,
151            ax_settings=ax_settings,
152            fig_settings=fig_settings,
153            plot_settings=plot_settings,
154        )
155
156        if fig_settings.figname is None:
157            if tools.with_reticulate() or html_show:
158                mpld3.show(fig, open_browser=True)
159            else:
160                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

162    def plot_catchment_surface_error(
163        self,
164        ax_settings: dict = {},
165        fig_settings: dict = {},
166        html_show: bool = False,
167    ):
168        """
169        Plot the modeled surface vs the observed surface. Check its consistency.
170         :param ax_settings, any properties of plot.ax_properties() class can be defined
171         in this dictionnary, defaults to {}
172        :type ax_settings: dict, optional
173        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
174         plot.fig_properties() class can be defined in this dictionnary, defaults to {}
175        :param html_show: Display the figure in an html page with your navigator, defaults
176         to False
177        :type html_show: bool, optional
178
179        """
180
181        default_ax_settings = plot.ax_properties(
182            title="Catchment surface error",
183            xlabel="Catchments",
184            ylabel="(Ssim - Sobs)/Sobs",
185        )
186        default_ax_settings.update(**ax_settings)
187
188        fig_settings = plot.fig_properties(**fig_settings)
189
190        if not hasattr(self._parent_class.mymesh, "mesh"):
191            raise ValueError("No smash mesh found. Build the mesh first.")
192
193        fig, ax = plot.plot_catchment_surface_error(
194            mesh=self._parent_class.mymesh.mesh,
195            ax_settings=ax_settings,
196            fig_settings=fig_settings,
197        )
198
199        if fig_settings.figname is None:
200            if tools.with_reticulate() or html_show:
201                mpld3.show(fig, open_browser=True)
202            else:
203                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

608    def plot_spatial_stats(
609        self,
610        stats: str = "max",
611        vmin: float | None = 0,
612        vmax: float | None = None,
613        ax_settings: dict = {},
614        fig_settings: dict = {},
615        html_show: bool = False,
616    ):
617        """
618        Plot the map of a given spatial statistic.
619        :param stats: The statistic to plot, choice are
620         'max, min, mean, median, q20, q80', defaults to "max"
621        :type stats: str, optional
622        ::param vmin: Minimal bounds value for the colorbar, defaults to 0
623        :type vmin: float, optional
624        :param vmax: Maximal bounds value for the colorbar, defaults to None
625        :type vmax: float, optional
626        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
627         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
628        :type ax_settings: dict, optional
629        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
630         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
631        :type fig_settings: dict, optional
632        :param html_show: Display the figure in an html page with your navigator, defaults
633         to False
634        :type html_show: bool, optional
635
636        """
637
638        fig_settings = plot.fig_properties(**fig_settings)
639
640        if not hasattr(self._plot_object.mystats.spatial_stats.results, stats):
641            raise ValueError(
642                f"Statistical results `{stats}` not found. Choice are: "
643                "[min, max, mean, median, q20, q80]"
644            )
645
646        stats_matrix = getattr(
647            self._plot_object.mystats.spatial_stats.results,
648            stats,
649        )
650        default_ax_settings = plot.ax_properties(
651            title="Maximal Discharges on periode"
652            f" {self._plot_object.smash.setup.start_time} -"
653            f" {self._plot_object.smash.setup.end_time}",
654            xlabel="Coords X",
655            ylabel="Coords_Y",
656            clabel="Discharge (m^3/s)",
657            cmap="viridis",
658        )
659        default_ax_settings.update(**ax_settings)
660
661        fig, ax = plot.plot_image(
662            matrice=stats_matrix,
663            bbox=geo_toolbox.get_bbox_from_smash_mesh(
664                self._parent_class.mymesh.mesh
665            ),
666            vmin=vmin,
667            vmax=vmax,
668            mask=self._plot_object.smash.mesh.active_cell,
669            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
670            ax_settings=default_ax_settings,
671            fig_settings=fig_settings,
672        )
673
674        if fig_settings.figname is None:
675            if tools.with_reticulate() or html_show:
676                mpld3.show(fig, open_browser=True)
677            else:
678                fig.show()
679
680        # 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

682    def plot_hydrograph(
683        self,
684        columns: list | None = [],
685        outlets_name: list = [],
686        plot_rainfall: bool = True,
687        ax_settings: dict = {},
688        fig_settings: dict = {},
689        plot_settings_sim: dict = {},
690        plot_settings_obs: dict = {},
691        html_show: bool = False,
692    ):
693        """
694        Plot the simulated and the observed hydrogram for different outlets.
695
696        :param columns: Columns of the matrix to plot (outlets), defaults to []
697        :type columns: list | None, optional
698        :param outlets_name: List of the outlets name to plot, defaults to []
699        :type outlets_name: list, optional
700        :param plot_rainfall: Plot the rainfall on the graphics, defaults to True
701        :type plot_rainfall: bool, optional
702        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
703         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
704        :type ax_settings: dict, optional
705        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
706         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
707        :type fig_settings: dict, optional
708        :param plot_settings_sim: Parameters of the matplotlib curves. Any propoerties of
709         plot.plot_properties() class ca be defined in this dictionnary, defaults to {}
710        :type plot_settings_sim: dict, optional
711        :param plot_settings_obs: DParameters of the matplotlib curves. Any propoerties of
712         plot.plot_properties() class ca be defined in this dictionnary, defaults to {}
713        :type plot_settings_obs: dict, optional
714        :pparam html_show: Display the figure in an html page with your navigator, defaults
715         to False
716        :type html_show: bool, optional
717
718        """
719
720        fig_settings = plot.fig_properties(**fig_settings)
721
722        if len(outlets_name) > 0:
723            columns = tools.array_isin(
724                self._plot_object.smash.mesh.code,
725                np.array(outlets_name),
726            )
727        elif len(columns) > 0:
728            outlets_name = [
729                self._plot_object.smash.mesh.code[i] for i in columns
730            ]
731
732        if columns is None:
733            columns = list(
734                range(0, self._plot_object.smash.response.q.shape[0])
735            )
736            outlets_name = list(self._plot_object.smash.mesh.code)
737
738        if len(columns) == 0:
739            columns = [0]
740            outlets_name = [list(self._plot_object.smash.mesh.code)[0]]
741
742        fig, ax = plot.plot_hydrograph(
743            model=self._plot_object.smash,
744            columns=columns,
745            outlets_name=outlets_name,
746            plot_rainfall=plot_rainfall,
747            ax_settings=ax_settings,
748            fig_settings=fig_settings,
749            plot_settings_sim=plot_settings_sim,
750            plot_settings_obs=plot_settings_obs,
751        )
752
753        if fig_settings.figname is None:
754            if tools.with_reticulate() or html_show:
755                mpld3.show(fig, open_browser=True)
756            else:
757                fig.show()
758
759        # 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

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

826    def plot_outlet_stats(
827        self,
828        columns: list | None = None,
829        outlets_name: list = [],
830        stat: str = "max",
831        ax_settings: dict = {},
832        fig_settings: dict = {},
833        html_show: bool = False,
834    ):
835        """
836        Plot a statistical criteria for a given list of outlet.
837        :param columns: Columns of the matrix to plot (outlets), defaults to []
838        :type columns: list | None, optional
839        :param outlets_name: List of the outlets name to plot, defaults to []
840        :type outlets_name: list, optional
841        :param misfit: The misfit criteria to plot, choice are
842        "nse, nnse, rmse, nrmse, se, kge", defaults to "nse"
843        :type misfit: str, optional
844        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
845         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
846        :type ax_settings: dict, optional
847        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
848         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
849        :type fig_settings: dict, optional
850        :param html_show: Display the figure in an html page with your navigator, defaults
851         to False
852        :type html_show: bool, optional
853
854        """
855
856        fig_settings = plot.fig_properties(**fig_settings)
857
858        values_sim = getattr(
859            self._plot_object.mystats.outlets_stats.results_sim, stat
860        )
861        values_obs = getattr(
862            self._plot_object.mystats.outlets_stats.results_obs, stat
863        )
864
865        if len(outlets_name) > 0:
866            columns = tools.array_isin(
867                self._plot_object.smash.mesh.code,
868                np.array(outlets_name),
869            )
870
871        if columns is None:
872            columns = list(
873                range(0, self._plot_object.smash.response.q.shape[0])
874            )
875            outlets_name = list(self._plot_object.smash.mesh.code)
876
877        fig, ax = plot.plot_outlet_stats(
878            values_sim=values_sim[columns],
879            values_obs=values_obs[columns],
880            names=outlets_name,
881            columns=None,
882            stat=stat,
883            ax_settings=ax_settings,
884            fig_settings=fig_settings,
885        )
886
887        if fig_settings.figname is None:
888            if tools.with_reticulate() or html_show:
889                mpld3.show(fig, open_browser=True)
890            else:
891                fig.show()
892
893        # 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

 895    def multiplot_misfit(
 896        self,
 897        columns: list | None = None,
 898        outlets_name: list = [],
 899        misfit: list = [
 900            "nse",
 901            "nnse",
 902            "kge",
 903            "mse",
 904            "rmse",
 905            "nrmse",
 906            "se",
 907            "mae",
 908            "mape",
 909            "lgrm",
 910        ],
 911        ax_settings: dict = {},
 912        fig_settings: dict = {},
 913        html_show: bool = False,
 914    ):
 915        """
 916        Plot misfit criterium for a given list of outlets.
 917
 918        :param columns: Columns of the matrix to plot (outlets), defaults to []
 919        :type columns: list | None, optional
 920        :param outlets_name: List of the outlets name to plot, defaults to []
 921        :type outlets_name: list, optional
 922        :param misfit: The misfit criteria to plot, list of criteria among
 923        "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
 924        :type misfit: str, optional
 925        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
 926         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
 927        :type ax_settings: dict, optional
 928        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
 929         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
 930        :type fig_settings: dict, optional
 931        :param html_show: Display the figure in an html page with your navigator, defaults
 932         to False
 933        :type html_show: bool, optional
 934
 935        """
 936
 937        fig_settings = plot.fig_properties(**fig_settings)
 938
 939        if len(outlets_name) > 0:
 940            columns = tools.array_isin(
 941                self._plot_object.smash.mesh.code,
 942                np.array(outlets_name),
 943            )
 944
 945        if columns is None:
 946            columns = list(
 947                range(0, self._plot_object.smash.response.q.shape[0])
 948            )
 949            outlets_name = list(self._plot_object.smash.mesh.code)
 950
 951        yfig = int(np.sqrt(len(misfit)))
 952        xfig = int(np.ceil(len(misfit) / yfig))
 953
 954        fig, axs = plt.subplots(
 955            xfig,
 956            yfig,
 957            constrained_layout=True,
 958        )
 959
 960        # for ax in axs:
 961        #     ax.set_axis_off()
 962
 963        for ax, crit in zip(
 964            axs.flat,
 965            misfit,
 966        ):
 967
 968            # ax.set_axis_on()
 969            ax_settings["ylabel"] = f"{crit} criteria"
 970            ax_settings["title"] = f"{crit} criteria"
 971
 972            if hasattr(self._plot_object.mystats.misfit_stats.results, crit):
 973                values = getattr(
 974                    self._plot_object.mystats.misfit_stats.results, crit
 975                )
 976            else:
 977                raise ValueError(
 978                    f"`{crit}` is not a valid statistic. choice are:"
 979                    "[nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge]"
 980                )
 981
 982            fig, ax = plot.plot_misfit(
 983                values=values[columns],
 984                names=np.array(outlets_name),
 985                columns=None,
 986                misfit=crit,
 987                figure=(fig, ax),
 988                ax_settings=ax_settings,
 989            )
 990
 991        [fig.delaxes(ax) for ax in axs.flatten() if not ax.has_data()]
 992        fig_settings.change((fig, ax))
 993
 994        if fig_settings.figname is None:
 995            if tools.with_reticulate() or html_show:
 996                mpld3.show(fig, open_browser=True)
 997            else:
 998                fig.show()
 999
1000        # 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

1002    def plot_misfit_map(
1003        self,
1004        misfit: str = "nse",
1005        coef_hydro: float = 99.0,
1006        ax_settings: dict = {},
1007        fig_settings: dict = {},
1008        plot_settings: dict = {},
1009        html_show: bool = False,
1010    ):
1011        """
1012        Plot a map of a misfit criteria.
1013
1014        :param columns: Columns of the matrix to plot (outlets), defaults to []
1015        :type columns: list | None, optional
1016        :param outlets_name: List of the outlets name to plot, defaults to []
1017        :type outlets_name: list, optional
1018        :param misfit: The misfit criteria to plot, choice are
1019        "nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge", defaults to "nse"
1020        :type misfit: str, optional
1021        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
1022         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
1023        :type ax_settings: dict, optional
1024        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
1025         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
1026        :type fig_settings: dict, optional
1027        :param html_show: Display the figure in an html page with your navigator, defaults
1028         to False
1029        :type html_show: bool, optional
1030
1031        """
1032
1033        if hasattr(self._plot_object.mystats.misfit_stats.results, misfit):
1034            values = getattr(
1035                self._plot_object.mystats.misfit_stats.results, misfit
1036            )
1037        else:
1038            raise ValueError(
1039                f"`{misfit}` is not a valid statistic. choice are:"
1040                "[nse, nnse, mse, rmse, nrmse, se, mae, mape, lgrm, kge]"
1041            )
1042
1043        fig_settings = plot.fig_properties(**fig_settings)
1044
1045        name = self._plot_object.smash.mesh.code
1046        mesh = self._parent_class.mymesh.mesh
1047
1048        fig, ax = plot.plot_misfit_map(
1049            values=values,
1050            names=name,
1051            mesh=mesh,
1052            misfit=misfit,
1053            coef_hydro=coef_hydro,
1054            ax_settings=ax_settings,
1055            fig_settings=fig_settings,
1056            plot_settings=plot_settings,
1057        )
1058
1059        if fig_settings.figname is None:
1060            if tools.with_reticulate() or html_show:
1061                mpld3.show(fig, open_browser=True)
1062            else:
1063                fig.show()
1064
1065        # 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

1067    def multiplot_parameters(
1068        self,
1069        mask_active_cell=False,
1070        ax_settings={},
1071        fig_settings={},
1072        html_show: bool = False,
1073    ):
1074        """
1075        Multiplot map of every Smash parameters
1076        :param mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
1077        :type mask_active_cell: bool, False, optional
1078        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
1079         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
1080        :type ax_settings: dict, optional
1081        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
1082         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
1083        :type fig_settings: dict, optional
1084        :param html_show: Display the figure in an html page with your navigator, defaults
1085         to False
1086        :type html_show: bool, optional
1087
1088        """
1089
1090        default_fig_settings = plot.fig_properties(xsize=8, ysize=8)
1091        default_fig_settings.update(**fig_settings)
1092
1093        param = list(self._plot_object.smash.rr_parameters.keys)
1094
1095        if mask_active_cell:
1096            mask = self._plot_object.smash.mesh.active_cell
1097        else:
1098            mask = None
1099
1100        yfig = int(np.sqrt(len(param)))
1101        xfig = int(np.ceil(len(param) / yfig))
1102
1103        fig, axs = plt.subplots(
1104            xfig,
1105            yfig,
1106            constrained_layout=False,
1107        )
1108        plt.subplots_adjust(
1109            left=None,
1110            bottom=None,
1111            right=None,
1112            top=None,
1113            wspace=0.5,
1114            hspace=0.5,
1115        )
1116        for ax, p in zip(axs.flat, param):
1117
1118            default_ax_settings = plot.ax_properties(
1119                title=f"{p} parameters map",
1120                xlabel="Coords X",
1121                ylabel="Coords_Y",
1122                clabel=f"{p} parameter value",
1123                cmap="viridis",
1124            )
1125            default_ax_settings.update(**ax_settings)
1126
1127            z = param.index(p)
1128
1129            fig, ax = plot.plot_image(
1130                matrice=self._plot_object.smash.rr_parameters.values[:, :, z],
1131                bbox=geo_toolbox.get_bbox_from_smash_mesh(
1132                    self._parent_class.mymesh.mesh
1133                ),
1134                mask=mask,
1135                vmin=0.0,
1136                catchment_polygon=self._parent_class.mymesh.catchment_polygon,
1137                ax_settings=default_ax_settings,
1138                figure=[fig, ax],
1139            )
1140
1141        [fig.delaxes(ax) for ax in axs.flatten() if not ax.has_data()]
1142        default_fig_settings.change((fig, axs))
1143
1144        if default_fig_settings.figname is None or html_show:
1145            if tools.with_reticulate():
1146                mpld3.show(fig, open_browser=True)
1147            else:
1148                fig.show()
1149
1150        # 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

1152    def plot_parameters(
1153        self,
1154        param="cp",
1155        mask_active_cell=False,
1156        vmin=0.0,
1157        vmax=None,
1158        ax_settings={},
1159        fig_settings={},
1160        html_show: bool = False,
1161    ):
1162        """
1163        Plot a map of a Smash parameters
1164        :param param: Name of the parameter to plot, defaults to "cp"
1165        :type param: str, optional
1166        :param mask_active_cell: Use the mask of the active cell to hide the non-active cell, defaults to False
1167        :type mask_active_cell: bool, False, optional
1168        :param vmin: Minimum value of the colorbar, defaults to 0.0
1169        :type vmin: float, optional
1170        :param vmax: Maximum value of the colorbar, defaults to None
1171        :type vmax: float, optional
1172        :param ax_settings: Parameters of the matplotlib figure 'ax'. Any propoerties of
1173         plot.ax_properties() class ca be defined in this dictionnary, defaults to {}
1174        :type ax_settings: dict, optional
1175        :param fig_settings: Parameters of the matplotlib figure 'fig'. Any propoerties of
1176         plot.fig_properties() class ca be defined in this dictionnary, defaults to {}
1177        :type fig_settings: dict, optional
1178        :param html_show: Display the figure in an html page with your navigator, defaults
1179         to False
1180        :type html_show: bool, optional
1181        """
1182
1183        fig_settings = plot.fig_properties(**fig_settings)
1184
1185        list_param = list(self._plot_object.smash.rr_parameters.keys)
1186        z = list_param.index(param)
1187
1188        if mask_active_cell:
1189            mask = self._plot_object.smash.mesh.active_cell
1190        else:
1191            mask = None
1192
1193        fig, axs = plt.subplots()
1194
1195        default_ax_settings = plot.ax_properties(
1196            title=f"{param} parameters map",
1197            xlabel="Coords X",
1198            ylabel="Coords_Y",
1199            clabel=f"{param} parameter value",
1200            cmap="viridis",
1201        )
1202        default_ax_settings.update(**ax_settings)
1203
1204        fig, ax = plot.plot_image(
1205            matrice=self._plot_object.smash.rr_parameters.values[:, :, z],
1206            bbox=geo_toolbox.get_bbox_from_smash_mesh(
1207                self._parent_class.mymesh.mesh
1208            ),
1209            mask=mask,
1210            vmin=vmin,
1211            vmax=vmax,
1212            catchment_polygon=self._parent_class.mymesh.catchment_polygon,
1213            ax_settings=default_ax_settings,
1214        )
1215
1216        fig_settings.change((fig, axs))
1217
1218        if fig_settings.figname is None or html_show:
1219            if tools.with_reticulate():
1220                mpld3.show(fig, open_browser=True)
1221            else:
1222                fig.show()
1223
1224        # 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