smashbox 1.0__py2.py3-none-any.whl

smashbox/tutorial_R_graffas.r

@@ -0,0 +1,88 @@
+
+#Graffas Tutorial - 2
+
+library(reticulate)
+use_virtualenv("/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/smashbox_env_21/") #use a specific python environnement
+
+#import the package smashbox (must be installed in the python environnement)
+smashbox <- import("smashbox")
+
+path_to_graffas_rainfall="/nas/RHAX/UTILISATEURS/kevin.tartour/2025_Graffas/SPATIAL/Gapeau/DataOutput/simul/RRsim_Gapeau_calage_reso_1000_res_1000_twin1_SMASH.Rdata"
+GraffasRainfall=load(path_to_graffas_rainfall)
+
+#get the bbox for Smash
+bbox=smashbox$tools$tools$infograffas_bbox_extractor(info_simu_smash)
+
+
+#Main initialisation of the module
+sb <- smashbox$SmashBox()
+sb$myparam$set_param("bbox", bbox)
+sb$myparam$set_param("outlets_database", "db_sites")
+
+sb$myparam$set_param(
+  "outlets_shapefile",
+  "/nas/RHAX/DONNEES/SIG/BASSINS/CONTOUR/SITES_L93/Hydro_Bassins.shp"
+)
+
+sb$newmodel("gapeau")
+
+sb$gapeau$generate_mesh()
+
+sb$gapeau$myplot$plot_mesh(fig_settings=list("figname"="/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/gapeau_mesh.png"))
+
+#Make a warmup during 365 days before the start-time found in the setup. This step use real rainfall data.
+sb$gapeau$model_warmup(warmup=365)
+
+#1- Compute Qantile for a "shorter" period
+
+sb$gapeau$atmos_data_connector(input_prcp=RRsim_3D,input_start_time="2020-01-01 01:00")
+sb$gapeau$model()
+sb$gapeau$forward_run(return_options=list("q_domain"= TRUE))
+sb$gapeau$mystats$fquantile_stats(
+  chunk_size=365, estimate_method="MLE", ncpu=6, fit="gumbel", compute_uncertaintisb=FALSE,
+)
+
+#2-Compute Qantile for a very long period
+
+#we split the period in 3 blocs (chunk))
+chunk_size=as.integer(dim(RRsim_3D)[3]/3)
+for (i in 0:2){
+  #send the rainfall data (Graffas) to smash
+  sb$gapeau$atmos_data_connector(input_prcp=RRsim_3D[,,(i*chunk_size):((i+1)*chunk_size)])
+  #generate the smash model
+  sb$gapeau$model()
+  #run the model with option invert_statsb=True : we use the final states as initial states except for the 1st chunk
+  sb$gapeau$forward_run(invert_statsb=TRUE,return_options=list("q_domain"= TRUE))
+  #compute the annual maxima over each chunk: use option cumulated_maxima=True to store and accumulate these maxima
+  sb$gapeau$mystats$fmaxima_stats(
+    chunk_size=365, cumulated_maxima=TRUE,
+  )
+}
+
+#finally adjust an extrem law over the maxima and compute the discharges quantile.
+sb$gapeau$mystats$fquantile_stats(
+  chunk_size=365, compute_uncertaintisb=TRUE
+)
+
+# Figures:
+
+sb$gapeau$myplot$plot_xy_quantile(
+  duration=1,
+  X=as.integer(15),
+  Y=as.integer(25),
+  fig_settings=list("figname"= "/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/quantile_XY_1h.png", "font_ratio"= 2),
+  ax_settings=list("legend_fontsize"= 20),
+)
+
+sb$gapeau$myplot$plot_outlets_quantile(duration=1,fig_settings=list("figname"= "/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/quantile_outlets.png", "font_ratio"= 2))
+
+sb$gapeau$myplot$plot_spatial_quantile(duration=1, T=2, fig_settings=list("figname"= "/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/quantile_spatial_1hT2.png", "font_ratio"= 2))
+
+sb$gapeau$myplot$multiplot_spatial_quantile(fig_settings=list("figname"= "/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/quantile_spatial_multiplot.png", "font_ratio"= 1))
+
+
+sb$gapeau$myplot$multiplot_parameters(
+  fig_settings=list("figname"= "/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/gapeau_parameters.png")
+)
+
+

smashbox/tutorial_R_graffas_local.r

@@ -0,0 +1,33 @@
+
+#Graffas Tutorial - 2
+
+library(reticulate)
+use_virtualenv("/home/maxime/python_venv/easysmash/") #use a specific python environnement
+
+#import the package smashbox (must be installed in the python environnement)
+smashbox <- import("smashbox")
+
+path_to_graffas_rainfall="~/smashbox_tmp/RRsim_Gapeau_calage_reso_1000_res_1000_twin1_SMASH.Rdata"
+GraffasRainfall=load(path_to_graffas_rainfall)
+
+#get the bbox for Smash
+bbox=smashbox$tools$tools$infograffas_bbox_extractor(info_simu_smash)
+
+
+#Main initialisation of the module
+sb <- smashbox$SmashBox()
+sb$myparam$set_param("bbox", bbox)
+sb$myparam$set_param("outlets_database", "db_sites")
+
+
+
+sb$newmodel("gapeau")
+
+sb$gapeau$generate_mesh()
+
+sb$gapeau$mymesh$mesh["nrow"]
+sb$gapeau$mymesh$mesh["ncol"]
+
+
+sb$gapeau$atmos_data_connector(input_prcp=RRsim_3D,input_start_time="2020-01-01 01:00")
+RRsim_3D

smashbox/tutorial_python.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Aug 21 12:03:55 2025
+
+@author: maxime
+"""
+
+
+if __name__ == "__main__":
+
+    import smashbox
+
+    bbox = {"left": 875000.0, "bottom": 6228000.0, "right": 1001000.0, "top": 6320000.0}
+
+    sb = smashbox.SmashBox()
+
+    sb.myparam.set_param("bbox", bbox)
+    sb.myparam.set_param("outlets_database", "db_sites")
+    sb.myparam.set_param("smash_parameters_dt", 3600.0)
+
+    # RHAX
+    sb.myparam.set_param(
+        "outlets_shapefile",
+        "/nas/RHAX/DONNEES/SIG/BASSINS/CONTOUR/SITES_L93/Hydro_Bassins.shp",
+    )
+
+    sb.newmodel("rex")
+
+    sb.rex.mysetup.update_setup(
+        {
+            "start_time": "2014-01-01 00:00",
+            "end_time": "2014-02-01 00:00",
+        }
+    )
+
+    # MAX
+    # sb.myparam.set_param(
+    #     "outlets_shapefile",
+    #     "/home/maxime/DEV/easysmash/smashbox/smashbox/asset/shapefile/Hydro_Bassins.shp",
+    # )
+
+    # sb.newmodel("rex")
+
+    # sb.rex.mysetup.update_setup(
+    #     {
+    #         "pet_directory": "/home/maxime/DATA/ETP-SFR-FRA-INTERA_L93",
+    #         "prcp_directory": "/home/maxime/DATA/PLUIE",
+    #         "qobs_directory": "/home/maxime/DATA/QOBS_SITE_60M",
+    #         "start_time": "2014-01-01 00:00",
+    #         "end_time": "2014-02-01 00:00",
+    #     }
+    # )
+
+    sb.rex.generate_mesh(
+        query="(SURF>40) & (INFLUENCE=='Influence nulle ou faible')", area_error_th=0.2
+    )
+
+    # optimize parameters if required
+    # sb.rex.optimize()
+
+    sb.rex.myplot.plot_mesh(fig_settings={"figname": "output/mesh.png"})
+    sb.rex.myplot.plot_catchment_surface_error(
+        fig_settings={"figname": "output/mesh_surface_error.png"}
+    )
+    sb.rex.myplot.plot_catchment_surface_consistency(
+        fig_settings={"figname": "output/mesh_surface_consistency.png"}
+    )
+
+    sb.rex.model()
+    sb.rex.forward_run(return_options={"q_domain": True}, warmup=100)
+
+    sb.rex.mystats.foutlets_stats()
+    sb.rex.mystats.fspatial_stats()
+    sb.rex.mystats.fmisfit_stats()
+
+    sb.rex.myplot.multiplot_parameters(
+        fig_settings={"figname": "output/muliplot_parameters.png"}
+    )
+    sb.rex.myplot.plot_parameters(fig_settings={"figname": "output/cp_parameters.png"})
+
+    sb.rex.myplot.plot_outlet_stats(
+        fig_settings={"figname": "output/outlets_max_discharges.png"}
+    )
+    sb.rex.myplot.plot_hydrograph(
+        fig_settings={"figname": "output/outlet_discharges.png"}
+    )
+    sb.rex.myplot.plot_spatial_stats(
+        fig_settings={"figname": "output/spatial_max_discharges.png"}
+    )
+
+    sb.rex.myplot.multiplot_misfit(
+        fig_settings={
+            "figname": "output/multiplot_nse_misfit.png",
+            "xsize": 15,
+            "ysize": 15,
+        }
+    )
+    sb.rex.myplot.plot_misfit(
+        misfit="nnse", fig_settings={"figname": "output/nnse_misfit.png"}
+    )
+    sb.rex.myplot.plot_misfit_map(fig_settings={"figname": "output/map_nse_misfit.png"})

smashbox/tutorial_readme.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+
+if __name__ == "__main__":
+
+    import smashbox
+    import numpy as np
+
+    bbox = {"left": 925000.0, "bottom": 6230000.0, "right": 974000.0, "top": 6255000.0}
+
+    sb = smashbox.SmashBox()
+
+    sb.myparam.set_param("bbox", bbox)
+    sb.myparam.set_param(
+        "smash_parameters", "/home/maxime/DEV/smashbox/smashbox/asset/params"
+    )
+    sb.myparam.set_param(
+        "outlets_database",
+        "/home/maxime/DEV/smashbox/smashbox/asset/outlets/db_sites.csv",
+    )
+
+    sb.newmodel("graffas_zone")
+    sb.graffas_zone.mysetup.load_setup("setup_rhax_gr4_dt3600")
+
+    sb.graffas_zone.mysetup.update_setup(
+        {
+            "pet_directory": "/home/maxime/DATA/ETP-SFR-FRA-INTERA_L93",
+            "prcp_directory": "/home/maxime/DATA/PLUIE",
+            "qobs_directory": "/home/maxime/DATA/QOBS_SITE_60M",
+        }
+    )  # Change value of the Smash setup
+
+    sb.graffas_zone.generate_mesh(
+        query="(SURF>20) & (INFLUENCE=='Influence nulle ou faible')"
+    )  # direct method to build the mesh (recommended)
+
+    sb.graffas_zone.myplot.plot_catchment_surface_consistency(
+        fig_settings={
+            "figname": "../images/mesh_surface_consistency.png",
+            "xsize": 4,
+            "ysize": 4,
+            "font_ratio": 1,
+        },
+        ax_settings={"title_fontsize": 12},
+    )
+    sb.graffas_zone.myplot.plot_catchment_surface_error(
+        fig_settings={
+            "figname": "../images/mesh_surface_error.png",
+            "xsize": 4,
+            "ysize": 4,
+            "font_ratio": 1,
+        },
+        ax_settings={"title_fontsize": 12},
+    )
+
+    sb.graffas_zone.myplot.plot_mesh(
+        fig_settings={
+            "figname": "../images/mesh.png",
+            "xsize": 6,
+            "ysize": 4,
+        },
+        ax_settings={"title_fontsize": 14},
+    )
+
+    nrow = sb.graffas_zone.mymesh.mesh["nrow"]
+    ncol = sb.graffas_zone.mymesh.mesh["ncol"]
+    chunk_size = 18
+    nb_chunk = 21
+    graffas_prcp = np.zeros(shape=(nrow, ncol, nb_chunk * chunk_size))
+    fctr = 100
+    for i in range(nb_chunk):
+        graffas_prcp[:, :, i * chunk_size : (i + 1) * chunk_size] = (
+            fctr
+            * np.arange(i * chunk_size, (i + 1) * chunk_size)
+            / (chunk_size * nb_chunk)
+            * np.cos(np.arange(0, chunk_size * 10, 10) * np.pi / 180)
+        )
+    graffas_prcp = np.where(graffas_prcp < 0, 0.0, graffas_prcp)
+
+    sb.graffas_zone.model_warmup(warmup=365)
+
+    sb.graffas_zone.atmos_data_connector(input_prcp=graffas_prcp, input_dt=3600.0)
+
+    sb.graffas_zone.model()
+
+    sb.graffas_zone.myplot.plot_parameters(
+        param="cp",
+        fig_settings={
+            "figname": "../images/param_cp.png",
+            "xsize": 5,
+            "ysize": 5,
+        },
+        ax_settings={"font_ratio": 1},
+    )
+
+    sb.graffas_zone.myplot.multiplot_parameters(
+        fig_settings={
+            "figname": "../images/multiplot_param.png",
+            "font_ratio": 1,
+            "xsize": 7,
+            "ysize": 6,
+        },
+        ax_settings={"title_fontsize": 10, "font_ratio": 0.6},
+    )
+
+    sb.graffas_zone.forward_run(invert_states=True, return_options={"q_domain": True})
+
+    rand_q = np.random.rand(*sb.graffas_zone.mysmashmodel.response_data.q.shape)
+    sb.graffas_zone.mysmashmodel.response_data.q[
+        :
+    ] = sb.graffas_zone.mysmashmodel.response.q[
+        :
+    ] + sb.graffas_zone.mysmashmodel.response.q[
+        :
+    ] * (
+        rand_q[:] - 0.5
+    ) * np.repeat(
+        np.arange(rand_q.shape[0]).reshape((rand_q.shape[0], 1)), rand_q.shape[1], axis=1
+    )
+
+    sb.graffas_zone.mystats.fspatial_stats()
+    sb.graffas_zone.mystats.foutlets_stats()
+    sb.graffas_zone.mystats.fmisfit_stats(use_smash_metrics=False)
+    sb.graffas_zone.mystats.fmisfit_stats(use_smash_metrics=True)
+
+    # test des metrics
+    # -------------------------------------------------------
+    from smash.fcore import _mwd_metrics as smash_metrics
+
+    metric_list = ["nse", "kge", "lgrm", "mae", "mape", "mse", "nnse", "rmse", "se"]
+
+    for metric_name in metric_list:
+        # metric_name = "nse"
+        fmetric = getattr(smash_metrics, metric_name)
+        metric = np.zeros(shape=(len(sb.graffas_zone.mysmashmodel.mesh.code))) + np.nan
+        for i in range(len(sb.graffas_zone.mysmashmodel.mesh.code)):
+            qobs = sb.graffas_zone.mysmashmodel.response_data.q[i, :]
+            qsim = sb.graffas_zone.mysmashmodel.response.q[i, :]
+            metric[i] = fmetric(qobs, qsim)
+
+        if hasattr(sb.graffas_zone.mystats.misfit_stats.results, metric_name):
+            smashbox_metric = getattr(
+                sb.graffas_zone.mystats.misfit_stats.results, metric_name
+            )
+            print(f"diff on metric {metric_name}:")
+            print(smashbox_metric - metric)
+        else:
+            print(f"no metric {metric_name} found")
+
+    # -------------------------------------------------------
+
+    sb.graffas_zone.mystats.fquantile_stats(
+        chunk_size=3,
+        estimate_method="MLE",
+        ncpu=4,
+        fit="gumbel",
+        compute_uncertainties=False,
+    )
+
+    sb.graffas_zone.myplot.plot_outlets_quantile()
+    sb.graffas_zone.myplot.plot_outlets_quantile(quantile_obs=False)
+
+    sb.graffas_zone.mystats.fmaxima_stats(chunk_size=3, cumulated_maxima=True)
+
+    # import matplotlib.pyplot as plt
+
+    # var = "spatial_quantile_outlets"
+
+    # fig, ax = plt.subplots()
+
+    # var_outlets = getattr(es.graffas_zone.mystats.quantile_stats, var)
+
+    # for i in range(var_outlets.shape[0]):
+    #     ax.plot(var_outlets[i, :], "x", markersize=5)
+
+    # for i in range(len(es.graffas_zone.mymesh.mesh["code"])):
+    #     coords = sb.graffas_zone.mymesh.mesh["gauge_pos"][i]
+    #     var_outlets = getattr(
+    #         sb.graffas_zone.mystats.quantile_stats, var.removesuffix("_outlets")
+    #     )[coords[0], coords[1], :]
+
+    #     ax.plot(var_outlets[:, 1], "o", markersize=4)
+
+    # save the smashbox container:
+    sb.graffas_zone.save_model_container(path_to_hdf5="my_smashbox_data.hdf5")
+    dict_es = sb.graffas_zone.save_model_container()
+
+    sb.graffas_zone.myplot.plot_spatial_stats(
+        fig_settings={
+            "figname": "../images/spatial_stats_max.png",
+            "xsize": 5,
+            "ysize": 5,
+        },
+        ax_settings={"font_ratio": 0.8},
+    )
+
+    sb.graffas_zone.myplot.plot_xy_quantile(
+        X=20,
+        Y=25,
+        fig_settings={"figname": "../images/quantile_XY.png", "xsize": 4, "ysize": 4},
+        ax_settings={"font_ratio": 1},
+    )
+
+    sb.graffas_zone.myplot.plot_outlets_quantile(
+        fig_settings={
+            "figname": "../images/quantile_outlets.png",
+            "xsize": 6,
+            "ysize": 8,
+        },
+        ax_settings={"font_ratio": 0.8},
+    )
+
+    sb.graffas_zone.myplot.plot_spatial_quantile(
+        T=2,
+        duration=1,
+        fig_settings={
+            "figname": "../images/spatial_quantile.png",
+            "xsize": 4,
+            "ysize": 4,
+        },
+        ax_settings={"font_ratio": 0.8},
+    )
+
+    sb.graffas_zone.myplot.multiplot_spatial_quantile(
+        duration=1,
+        fig_settings={
+            "figname": "../images/multiplot_spatial_quantile.png",
+            "xsize": 6,
+            "ysize": 6,
+        },
+        ax_settings={"font_ratio": 0.6},
+    )
+
+    sb.graffas_zone.myplot.plot_hydrograph(
+        fig_settings={
+            "figname": "../images/hydrogram.png",
+        },
+    )
+
+    sb.graffas_zone.myplot.plot_misfit(
+        misfit="nse",
+        fig_settings={
+            "figname": "../images/nse2.png",
+            "xsize": 4,
+            "ysize": 3,
+        },
+    )
+
+    sb.graffas_zone.myplot.multiplot_misfit(
+        fig_settings={
+            "figname": "../images/multiplot_misfit2.png",
+            "xsize": 6,
+            "ysize": 6,
+        },
+        ax_settings={"font_ratio": 0.4},
+    )
+
+    sb.graffas_zone.myplot.plot_misfit_map(
+        misfit="nse",
+        fig_settings={"figname": "../images/misfit_map.png", "xsize": 8, "ysize": 6},
+        ax_settings={"font_ratio": 1},
+    )

smashbox/tutorial_report.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+if __name__ == "__main__":
+
+    ################ Test rapoort ################
+    import smashbox
+    import numpy as np
+
+    bbox = {"left": 875000.0, "bottom": 6228000.0, "right": 1001000.0, "top": 6320000.0}
+
+    sb = smashbox.SmashBox()
+
+    sb.myparam.set_param("bbox", bbox)
+
+    sb.newmodel("rex")
+
+    sb.rex.mysetup.update_setup({"read_pet": False})
+
+    sb.rex.generate_mesh(
+        query="(SURF>200) & (INFLUENCE=='Influence nulle ou faible')", area_error_th=0.2
+    )
+
+    sb.rex.myplot.plot_mesh()
+
+    ##########################################################
+    # Artificial rainfall
+    nrow = sb.rex.mymesh.mesh["nrow"]
+    ncol = sb.rex.mymesh.mesh["ncol"]
+    prcp = np.random.randint(-100, 100, size=(nrow, ncol, 365 * 24))
+    prcp = np.where(prcp < 0, 0.0, prcp)
+    ###########################################################
+
+    sb.rex.atmos_data_connector(input_prcp=prcp, input_dt=3600.0)
+    sb.rex.model()
+
+    sb.rex.mysmashmodel.atmos_data.pet = 0.0
+    sb.rex.forward_run(return_options={"q_domain": True}, invert_states=True)
+
+    ##########################################################
+    # Artificial observed discharge
+    rand = np.random.randint(-20, 20, sb.rex.mysmashmodel.response_data.q.shape) / 100.0
+    qsim = sb.rex.mysmashmodel.response.q[:]
+    sb.rex.mysmashmodel.response_data.q = qsim + qsim * rand
+    ##########################################################
+
+    sb.rex.mystats.fmisfit_stats()
+    sb.rex.mystats.fquantile_stats(
+        chunk_size=30,
+        estimate_method="MLE",
+        ncpu=6,
+        fit="gumbel",
+        compute_uncertainties=False,
+    )
+
+    sb.rex.myplot.multiplot_misfit()
+    sb.rex.myplot.multiplot_spatial_quantile()
+    sb.rex.myplot.plot_outlets_quantile()
+    sb.rex.myplot.plot_hydrograph()

smashbox/tutorials/Python_tutorial.md

@@ -0,0 +1,124 @@
+# Python tutorials
+
+This section contains some Python tutorials to achieve common task with SmashBox.
+
+Performing a REX
+----------------
+
+First of all, load your Python environment where SmashBox and Smash are installed (change the path according your installation).
+
+```shell
+source python_venv/smashbox/bin/activate
+```
+Then open a Python console and load the package EsaySmash
+
+```python
+import smashbox
+```
+
+Assume you need to perform a REX on a defined area. This area is defined by a bounding box 
+
+```python
+bbox={'left': 875000.0,
+ 'bottom': 6228000.0,
+ 'right': 1001000.0,
+ 'top': 6320000.0}
+```
+
+Configure the smashbox module: Set the bounding box, select the outlet database and configure the database fields.
+
+```python
+es = smashbox.SmashBox()
+es.myparam.set_param("bbox", bbox)
+```
+We are ready to create a container for your Smash simulation:
+
+```python
+es.newmodel("rex")
+```
+
+Then we need to adjust the setup. By default the setup `setup_rhax_gr4_dt3600` is automatically loaded. If needed, you can select an other one (see function `es.rex.mysetup.list_available_setup()`), and change some properties of the setup. On the rhax server, only the date must be configured. Path to data are already set, we use comephore 60M for the precipitation, the last extraction of the discharges at every sites (2025) and the daily potential evapotranspiration.
+
+```python
+es.rex.mysetup.update_setup(
+        {
+            "start_time": "2014-01-01 00:00",
+            "end_time": "2014-02-01 00:00",
+        }
+    )
+```
+
+Then we can build the mesh and add outlets with surface greater than 20 km², and automatically exclude outlets if the modeled surface error :math:`(Ssim - Sobs)/Sobs>0.2` (`area_error_th` option).
+
+```python
+es.rex.generate_mesh(query="(SURF>20) & (INFLUENCE=='Influence nulle ou faible')", area_error_th=0.2)
+```
+
+Few plots can help to validate our mesh with functions `smashbox.plot.myplot.myplot.plot_mesh` and `smashbox.plot.myplot.myplot.plot_catchment_surface_error` and `smashbox.plot.myplot.plot_catchment_surface_consistency`:
+
+```python
+
+es.rex.myplot.plot_mesh(fig_settings={"figname": "output/mesh.png"})
+es.rex.myplot.plot_catchment_surface_error(
+    fig_settings={"figname": "output/mesh_surface_error.png"}
+)
+es.rex.myplot.plot_catchment_surface_consistency(
+    fig_settings={"figname": "output/mesh_surface_consistency.png"}
+)
+
+```
+remark: if figname is not defined, the plot will be sent to the matplotlib interactive UI or to your web browser as html (if you run the code from R). However, this  feature is not working for remote server (perhaps try to ssh -X firefox).
+
+Let's now perform a forward run (the model will be build automatically), perform a warmup period of 100 days and return the discharge on the grid.
+
+```
+es.rex.forward_run(return_options={"q_domain": True}, warmup=100)
+```
+
+Statistics can be computed. `smashbox.stats.mystats.mystats.foutlets_stats` method compute basic discharges statistics at every outlets; `smashbox.stats.mystats.mystats.fspatial_stats` method compute basic spatial discharges statistics at every pixel; `smashbox.stats.mystats.mystats.fmisfit_stats` compute many misfits criteria at outlets.
+
+```python
+es.rex.mystats.foutlets_stats()
+es.rex.mystats.fspatial_stats()
+es.rex.mystats.fmisfit_stats()
+
+```
+
+Several figures can be plotted:
+
+First, we can plot the parameters First, we can plot the parameters with functions `smashbox.plot.myplot.myplot.plot_parameters` and `smashbox.plot.myplot.myplot.multiplot_parameters`:
+:
+```python
+es.rex.myplot.multiplot_parameters(
+    fig_settings={"figname": "output/muliplot_parameters.png"}
+)
+es.rex.myplot.plot_parameters(fig_settings={"figname": "output/cp_parameters.png"})
+```
+
+Then we can plot basic statistics with functions `smashbox.plot.myplot.myplot.plot_outlet_stats` and `smashbox.plot.myplot.myplot.plot_spatial_stats` :
+```Python
+es.rex.myplot.plot_outlet_stats(
+    fig_settings={"figname": "output/outlets_max_discharges.png"}
+)
+es.rex.myplot.plot_spatial_stats(
+    fig_settings={"figname": "output/spatial_max_discharges.png"}
+)
+```
+
+Let's plot an hydrogram (by default the first outlet is used) with functions `smashbox.plot.myplot.myplot.plot_hydrograph`:
+```Python
+es.rex.myplot.plot_hydrograph(fig_settings={"figname": "output/discharges_hydrogram.png"})
+```
+
+Finally, plot the misfit criteria with functions `smashbox.plot.myplot.myplot.multiplot_misfit` and `smashbox.plot.myplot.myplot.plot_misfit` and `smashbox.plot.myplot.plot_misfit_map` :
+```Python
+
+es.rex.myplot.multiplot_misfit(
+    fig_settings={"figname": "output/multiplot_nse_misfit.png", "xsize": 15, "ysize": 15}
+)
+es.rex.myplot.plot_misfit(
+    misfit="nnse", fig_settings={"figname": "output/nnse_misfit.png"}
+)
+es.rex.myplot.plot_misfit_map(fig_settings={"figname": "output/map_nse_misfit.png"})
+
+```