smashbox 1.0__py2.py3-none-any.whl

smashbox/test.py

@@ -0,0 +1,532 @@
+if __name__ == "__main__":
+
+    import smashbox
+
+    from smashbox import tools
+
+    @tools.tools.autocast_args
+    def test(
+        a: int | None = None,
+        b: None | int = None,
+        c: int | None = 1,
+        d: int = 2,
+        e: None = None,
+        f: None | dict | tuple = None,
+        g=1,
+    ):
+
+        print(a, b, c, d, e)
+
+    test(a=1.0, b=1.0, c=1.0, d=1.0, e=None, f=(2,), g=2)
+
+    # Main object creation
+    sb = smashbox.SmashBox()
+
+    # Main input parameters of main object: class param, attribute 'myparam'
+    # sb.currentmodel #current active model
+    sb.myparam.list_param()  # list the parameters of the current active model
+    sb.myparam.set_param(
+        "outlets_database",
+        "/home/maxime/DEV/smashbox/smashbox/asset/outlets/db_stations_example.csv",
+    )
+
+    sb.myparam.set_param(
+        "outlets_database_fields",
+        {"coord_x": "X_L93", "coord_y": "Y_L93", "area": "SURF", "id": "ID_HYDRO"},
+    )  # change/update/set the value of the parameter 'outlets_database_fields'.
+
+    sb.myparam.set_param(
+        "smash_parameters", "/home/maxime/DEV/smashbox/smashbox/asset/params"
+    )  # change the value of myparam used byRealCollobrier
+
+    # Read/write param
+    # sb.myparam.write_param("param.yaml") #write smashbox param
+    sb.myparam.load_param("param.yaml")  # load smashbox param
+
+    # New model creation
+    sb.newmodel(
+        "RealCollobrier"
+    )  # create a new model named RealCollobrier and copy the previous parameters used for mymodel1 (default behaviour, but it can turned off)
+
+    # create an second model with different parameters
+    sb.myparam.param.setup_file = "setup_rhax_gr5_dt3600.yaml"
+    sb.myparam.set_param(
+        "outlets_database_fields",
+        {"coord_x": "X", "coord_y": "Y", "area": "area", "id": "Nom"},
+    )  # change/update/set the value of the parameter 'outlets_database_fields'.
+    sb.newmodel(
+        "Lez"
+    )  # create a new model named RealCollobrier and copy the previous parameters used for mymodel1 (default behaviour, but it can turned off)
+
+    # Remove a model
+    sb.delmodel("Lez")
+
+    # Param associated to the model (hidden) has been copied
+    sb.RealCollobrier._myparam.list_param()  # Notice that myparam is also stored in each model object. So you can access to the model param inside the model attribute.
+    sb.RealCollobrier._myparam.param.epsg
+
+    # Setup utilities
+    sb.RealCollobrier.mysetup.setup  # print the setup to the screen
+    # sb.RealCollobrier.mysetup.write_setup("setup.yaml") #Write the Smash setup
+    sb.RealCollobrier.mysetup.load_setup("setup.yaml")  # Read a custom Smash setup
+    sb.RealCollobrier.mysetup.update_setup(
+        {
+            "hydrological_module": "gr4",
+            "end_time": "2014-01-01 12:00",
+            "start_time": "2014-01-01 01:00",
+            "pet_directory": "/home/maxime/DATA/ETP-SFR-FRA-INTERA_L93",
+            "prcp_directory": "/home/maxime/DATA/PLUIE",
+            "qobs_directory": "/home/maxime/DATA/QOBS",
+        }
+    )  # Change value of the Smash setup
+    sb.RealCollobrier.mysetup.setup  # print the setup to the screen
+
+    # Mesh utilities (hidden)
+    sb.RealCollobrier.mymesh.mesh  # print the mesh to the screen
+    sb.RealCollobrier.mymesh.make_mesh(
+        sb.RealCollobrier._myparam.param
+    )  # Undirect method to build mesh, depend on myparam (unrecomended)
+    sb.RealCollobrier.mymesh.mesh
+    sb.RealCollobrier.mymesh.write_mesh("mesh.hdf5")
+    sb.RealCollobrier.mymesh.load_mesh("mesh.hdf5")
+    sb.RealCollobrier.mymesh.mesh  # print the mesh to the screen
+
+    # Model utilities
+    sb.RealCollobrier.make_mesh()  # direct method to build the mesh (recommended)
+    sb.RealCollobrier.build_model()  # build the model with smash.Model()
+    sb.RealCollobrier.load_smashparam()  # extract the smash parameter from a parameters set and fill the attribute mysmashparameter
+    sb.RealCollobrier.write_smashparam(
+        "smashparam.hdf5"
+    )  # write the extracted parameter in an hdf5 database
+    sb.RealCollobrier.write_smashparam_to_geotiff("geotiff_smashparam")
+    sb.RealCollobrier.make_model(
+        run=True
+    )  # direct build, extract param and run (default is True). Use option run=False to only build the model and extract parameter
+
+    # Stat utilities
+
+    # plot utilities
+    sb.RealCollobrier.myplot.plot_mesh()
+
+    import smashbox
+    import smash
+    from smashbox.plot import plot
+
+    # Testing graffas connector
+    import numpy as np
+
+    bbox = {"left": 925000.0, "bottom": 6230000.0, "right": 974000.0, "top": 6255000.0}
+
+    # graffas_prcp = np.zeros(shape=(145, 170, 1300))
+    # rng = np.random.default_rng()
+    # graffas_prcp = (
+    #     graffas_prcp
+    #     + rng.multinomial(20, [0.2, 0.8], size=graffas_prcp.shape)[:, :, :, 0]
+    # )
+    # graffas_pet = np.zeros(shape=(142, 166, 17520)) + 1.0
+
+    # Main object creation
+    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.myparam.set_param(
+    #     "outlets_shapefile", "/home/maxime/DATA/BNBVlight/BNBV_light_bassins.shp"
+    # )
+    # sb.myparam.set_param("enhanced_smash_input_data", True)
+
+    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",
+        }
+    )  # Change value of the Smash setup
+
+    sb.graffas_zone.generate_mesh()  # direct method to build the mesh (recommended)
+
+    sb.graffas_zone.myplot.plot_catchment_surface_consistency(
+        fig_settings={
+            "figname": "../images/mesh_surface_consistency.png",
+            "xsize": 5,
+            "ysize": 5,
+            "font_ratio": 2,
+        },
+        ax_settings={"title_fontsize": 12},
+    )
+    sb.graffas_zone.myplot.plot_catchment_surface_error(
+        fig_settings={
+            "figname": "../images/mesh_surface_error.png",
+            "xsize": 5,
+            "ysize": 5,
+            "font_ratio": 2,
+        },
+        ax_settings={"title_fontsize": 12},
+    )
+
+    sb.graffas_zone.myplot.plot_mesh(
+        fig_settings={
+            "figname": "../images/mesh.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+        ax_settings={"title_fontsize": 20},
+    )
+
+    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.atmos_data_connector(input_prcp=graffas_prcp)
+    # sb.graffas_zone.atmos_data_connector(input_prcp=graffas_prcp, input_pet=graffas_pet)
+
+    sb.graffas_zone.model()
+
+    sb.graffas_zone.myplot.plot_parameters(
+        param="cp",
+        fig_settings={
+            "figname": "../images/param_cp.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+        ax_settings={"title_fontsize": 12},
+    )
+    sb.graffas_zone.myplot.multiplot_parameters(
+        fig_settings={
+            "figname": "../images/multiplot_param.png",
+            "xsize": 10,
+            "ysize": 10,
+            "font_ratio": 1,
+        },
+        ax_settings={"title_fontsize": 10, "font_ratio": 1},
+    )
+
+    # sb.graffas_zone.generate_model(
+    #     return_options={"q_domain": True}
+    # )  # build and run the model with smash.Model()
+
+    sb.graffas_zone.forward_run(invert_states=True, return_options={"q_domain": True})
+
+    # sb.graffas_zone.myplot.plot_parameters(param="cp")
+    # sb.graffas_zone.myplot.multiplot_parameters()
+    # import matplotlib.pyplot as plt
+    # from matplotlib.colors import LogNorm, SymLogNorm
+
+    # q = sb.graffas_zone.extra_smash_results.q_domain[:, :, 500]
+    # q = np.where(es.graffas_zone.mysmashmodel.mesh.active_cell == 0, np.nan, q)
+    # plt.imshow(q, norm=SymLogNorm(1e-4))
+
+    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()
+
+    sb.graffas_zone.mystats.fquantile_stats(
+        chunk_size=3,
+        estimate_method="MLE",
+        ncpu=6,
+        fit="gumbel",
+        compute_uncertainties=True,
+    )
+
+    # sb.graffas_zone.mystats.misfit.rmse()
+    # sb.graffas_zone.mystats.misfit.nse(outlets_name=["MedEst_528", "MedEst_617"])
+    # res = sb.graffas_zone.mystats.stats_misfit()
+
+    from smashbox.stats import stats
+
+    # results = stats.spatial_quantiles(
+    #     sb.graffas_zone.extra_smash_results.q_domain,
+    #     chunk_size=3,
+    #     quantile_duration=48,
+    #     estimate_method="MLE",
+    # )
+
+    # results = stats.spatial_quantiles(
+    #     sb.graffas_zone.extra_smash_results.q_domain,
+    #     chunk_size=3,
+    #     quantile_duration=72,
+    #     estimate_method="MLE",
+    # )
+
+    # array = stats.time_resample_array(
+    #     array=es.graffas_zone.extra_smash_results.q_domain,
+    #     quantile_duration=1,
+    #     model_time_step=3600,
+    #     t_axis=2,
+    # )
+    # array.shape
+
+    # stats.compute_maxima(
+    #     array=array,
+    #     t_axis=2,
+    #     nb_minimum_chunks=4,
+    #     chunk_size=2,
+    #     quantile_duration=48,
+    # )
+
+    # array = stats.time_resample_array(
+    #     array=es.graffas_zone.extra_smash_results.q_domain,
+    #     quantile_duration=48,
+    #     model_time_step=3600,
+    #     t_axis=2,
+    # )
+    # array.shape
+
+    # maxima = stats.compute_maxima(
+    #     array=array,
+    #     t_axis=2,
+    #     nb_minimum_chunks=5,
+    #     chunk_size=2,
+    #     quantile_duration=48,
+    # )
+
+    # sb.graffas_zone.mystats.fmaxima_stats(chunk_size=4, cumulated_maxima=False)
+
+    # sb.graffas_zone.mystats.fstats_quantile_2(
+    #     chunk_size=10, estimate_method="MLE", ncpu=6, fit="gumbel"
+    # )
+
+    # sb.graffas_zone.mystats.fmaxima_stats(chunk_size=2, cumulated_maxima=True)
+
+    # sb.graffas_zone.mystats.quantile_stats.spatial_cumulated_maxima[100, 10, :, 0]
+
+    sb.graffas_zone.myplot.plot_spatial_stats(
+        fig_settings={
+            "figname": "../images/spatial_stats_max.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+        ax_settings={"font_ratio": 1.0},
+    )
+
+    # results = stats.fit_quantile(
+    #     maxima=es.graffas_zone.mystats.quantile_stats.spatial_cumulated_maxima[
+    #         :, :, :, 0
+    #     ],
+    #     t_axis=2,
+    #     return_periods=[2, 5, 10, 20, 50, 100],
+    #     fit="gumbel",
+    #     estimate_method="MLE",
+    #     quantile_duration=1,
+    #     ncpu=6,
+    # )
+    # results = stats.parametric_bootstrap_uncertainties(q_results=results, ncpu=6)
+
+    # fig, ax = smashbox.plot.plot.plot_xy_quantile(
+    #     results,
+    #     X=100,
+    #     Y=10,
+    #     fig_settings={"figname": "../images/quantile_XY.png", "font_ratio": 2},
+    #     ax_settings={"legend_fontsize": 20},
+    # )
+
+    sb.graffas_zone.myplot.plot_xy_quantile(
+        X=20,
+        Y=25,
+        fig_settings={"figname": "../images/quantile_XY.png", "font_ratio": 2},
+        ax_settings={"legend_fontsize": 20},
+    )
+
+    sb.graffas_zone.myplot.plot_outlets_quantile(
+        fig_settings={
+            "figname": "../images/quantile_outlets.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+        ax_settings={"font_ratio": 0.5},
+    )
+
+    sb.graffas_zone.myplot.plot_spatial_quantile(
+        T=2,
+        duration=1,
+        fig_settings={
+            "figname": "../images/spatial_quantile.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+        ax_settings={"font_ratio": 1.5},
+    )
+
+    sb.graffas_zone.myplot.multiplot_spatial_quantile(
+        duration=1,
+        fig_settings={
+            "figname": "../images/multiplot_spatial_quantile.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+        ax_settings={"font_ratio": 1.0},
+    )
+
+    # fig, ax = plot.plot_chro(
+    #     sb.graffas_zone.mysmashmodel.response.q,
+    #     ax_settings={"title": "my title", "title_fontsize": 42},
+    #     plot_settings={"label": "discharge at gauge 0"},
+    # )
+
+    sb.graffas_zone.myplot.plot_hydrograph(
+        fig_settings={
+            "figname": "../images/hydrogram.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+    )
+
+    sb.graffas_zone.myplot.plot_misfit(
+        misfit="nse",
+        fig_settings={
+            "figname": "../images/nse.png",
+            "xsize": 10,
+            "ysize": 7,
+        },
+    )
+
+    sb.graffas_zone.myplot.multiplot_misfit(
+        fig_settings={
+            "figname": "../images/multiplot_misfit.png",
+            "xsize": 10,
+            "ysize": 10,
+        },
+    )
+
+    sb.graffas_zone.myplot.plot_misfit_map(
+        misfit="nse",
+        fig_settings={"figname": "../images/misfit_map.png", "xsize": 10, "ysize": 10},
+        ax_settings={"font_ratio": 1},
+    )
+
+    # sb.graffas_zone.export_parameters()
+
+    import smashbox
+    import smash
+    from smashbox.plot import plot
+
+    # Testing graffas connector
+    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("outlets_database", "db_sites")
+    sb.myparam.set_param(
+        "outlets_shapefile",
+        "/home/maxime/DEV/smashbox/smashbox/asset/shapefile/Hydro_Bassins.shp",
+    )
+
+    sb.myparam.set_param(
+        "outlets_database_fields",
+        {
+            "coord_x": "X_L93",
+            "coord_y": "Y_L93",
+            "area": "SURF",
+            "id": "CODE_SITE",
+        },
+    )
+
+    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>20)")
+    sb.rex.myplot.plot_mesh()
+
+    graffas_prcp = np.zeros(shape=(25, 49, 365 * 24 * 5)) + 1
+    rng = np.random.default_rng()
+    graffas_prcp = (
+        graffas_prcp
+        + rng.multinomial(20, [0.2, 0.8], size=graffas_prcp.shape)[:, :, :, 0]
+    )
+
+    sb.rex.atmos_data_connector(input_prcp=graffas_prcp[:, :, :])
+    sb.rex.forward_run(return_options={"q_domain": True})
+
+    sb.rex.mystats.fmaxima_stats(t_axis=2.0, chunk_size=365, cumulated_maxima=True)
+
+    graffas_prcp = np.zeros(shape=(25, 49, 365 * 24 * 5)) + 1
+    rng = np.random.default_rng()
+    graffas_prcp = (
+        graffas_prcp
+        + rng.multinomial(20, [0.2, 0.8], size=graffas_prcp.shape)[:, :, :, 0]
+    )
+
+    sb.rex.atmos_data_connector(input_prcp=graffas_prcp[:, :, :])
+    sb.rex.forward_run(invert_states=True, return_options={"q_domain": True})
+
+    sb.rex.mystats.fmaxima_stats(chunk_size=365, cumulated_maxima=True)
+
+    sb.rex.mystats.fquantile_stats(
+        chunk_size=365,
+        estimate_method="MLE",
+        ncpu=6,
+        fit="gumbel",
+        compute_uncertainties=True,
+    )
+
+    sb.rex.mystats.fquantile_stats2(
+        chunk_size=365, estimate_method="MLE", ncpu=6, fit="gumbel"
+    )
+
+    sb.rex.myplot.plot_outlets_quantile()
+    sb.rex.myplot.multiplot_spatial_quantile()
+
+    array = stats.time_resample_array(
+        array=sb.rex.extra_smash_results.q_domain,
+        quantile_duration=72,
+        model_time_step=3600,
+        t_axis=2,
+    )
+    array.shape
+
+    maxima = stats.compute_maxima(
+        array=array,
+        t_axis=2,
+        nb_minimum_chunks=4,
+        chunk_size=365,
+        quantile_duration=72,
+    )
+
+    sb.rex.mystats.fquantile_stats(
+        chunk_size=365, estimate_method="MLE", ncpu=6, fit="gumbel"
+    )

smashbox/test_average_stats.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Nov  4 14:11:45 2025
+
+@author: maxime
+"""
+
+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
+    )
+
+    ##########################################################
+    # Artificial rainfall
+    nrow = sb.rex.mymesh.mesh["nrow"]
+    ncol = sb.rex.mymesh.mesh["ncol"]
+    prcp = np.random.randint(-100, 100, size=(nrow, ncol, 24 * 30))
+    prcp = np.where(prcp < 0, 0.0, prcp)
+    ###########################################################
+
+    def model_creation(obj, prcp, qnoise):
+
+        obj.atmos_data_connector(input_prcp=prcp, input_dt=3600.0)
+        obj.model()
+
+        obj.mysmashmodel.atmos_data.pet = 0.0
+        obj.forward_run(return_options={"q_domain": True}, invert_states=True)
+
+        ##########################################################
+        # Artificial observed discharge
+        rand = (
+            np.random.randint(-qnoise, qnoise, obj.mysmashmodel.response_data.q.shape)
+            / 100.0
+        )
+        qsim = sb.rex.mysmashmodel.response.q[:]
+        obj.mysmashmodel.response_data.q = qsim + qsim * rand
+        ##########################################################
+
+    model_creation(sb.rex, prcp, 20.0)
+
+    sb.rex.mystats.fmisfit_stats()
+    sb.rex.mystats.foutlets_stats()
+    sb.rex.mystats.fspatial_stats()
+    sb.rex.mystats.fquantile_stats(
+        chunk_size=5,
+        estimate_method="MLE",
+        ncpu=6,
+        fit="gumbel",
+        compute_uncertainties=False,
+    )
+
+    sb.copymodel("rex", "rex2")
+    model_creation(sb.rex2, prcp * 1.5, 30.0)
+
+    sb.rex2.mystats.fmisfit_stats()
+    sb.rex2.mystats.foutlets_stats()
+    sb.rex2.mystats.fspatial_stats()
+    # sb.rex2.mystats.quantile_stats = sb.rex.mystats.quantile_stats
+    sb.rex2.mystats.fquantile_stats(
+        chunk_size=5,
+        estimate_method="MLE",
+        ncpu=6,
+        fit="gumbel",
+        compute_uncertainties=False,
+    )
+
+    sb.multimodel_statistics._get_model_list()
+
+    sb.multimodel_statistics.compute_multimodel_statistics()
+
+    sb.multimodel_statistics.compute_multimodel_statistics_misfit()
+    sb.multimodel_statistics.compute_multimodel_statistics_outlets()
+    sb.multimodel_statistics.compute_multimodel_statistics_outlets(obs=True)
+    sb.multimodel_statistics.compute_multimodel_statistics_spatial()
+    sb.multimodel_statistics.compute_multimodel_statistics_quantile()
+
+    sb.multimodel_statistics.multimodel_quantile_stats.Quantile_1h.Q_th.data.shape
+    sb.multimodel_statistics.multimodel_quantile_stats.Quantile_1h.Q_th.data[0, 60, 50, 0]
+    sb.multimodel_statistics.multimodel_quantile_stats.Quantile_1h.Q_th.data[1, 60, 50, 0]
+    sb.rex.mystats.quantile_stats.Quantile_1h.Q_th[60, 50, 0]
+    sb.rex2.mystats.quantile_stats.Quantile_1h.Q_th[60, 50, 0]
+
+    from smashbox.plot import plot
+
+    fig, ax = plot.plot_image(
+        sb.multimodel_statistics.multimodel_quantile_stats.Quantile_1h.Q_th.median[
+            :, :, 0
+        ]
+    )
+    fig.show()
+    fig, ax = plot.plot_image(sb.rex.mystats.quantile_stats.Quantile_1h.Q_th[:, :, 0])
+    fig.show()
+    fig, ax = plot.plot_image(sb.rex2.mystats.quantile_stats.Quantile_1h.Q_th[:, :, 0])
+    fig.show()
+
+    fig, ax = plot.plot_misfit(
+        sb.multimodel_statistics.multimodel_misfit_stats.nse.mean,
+    )
+    fig.show()
+    fig, ax = plot.plot_misfit(
+        sb.rex.mystats.misfit_stats.results.nse,
+    )
+    fig.show()
+    fig, ax = plot.plot_misfit(
+        sb.rex2.mystats.misfit_stats.results.nse,
+    )
+    fig.show()

smashbox/test_mesh.r

@@ -0,0 +1,8 @@
+#import reticulate module to be able to import python module
+library(reticulate)
+use_virtualenv("~/python_venv/smashbox") #use a specific python environnement
+
+
+#import the package smashbox (must be installed in the python environnement)
+smashbox <- import("smashbox")
+