smashbox 1.0__py2.py3-none-any.whl

smashbox/model/model.py

@@ -0,0 +1,829 @@
+import os
+import smash
+
+# import pyhdf5_handler
+# from pyhdf5_handler.src import hdf5_handler
+import numpy as np
+import pandas as pd
+import datetime
+
+# from smashbox.src import param
+from smashbox.model import setup
+from smashbox.model import mesh
+from smashbox.plot import myplot
+from smashbox.tools import geo_toolbox
+from smashbox.tools import tools
+from smashbox.model import atmos_data_connector
+from smashbox.stats import mystats
+from smashbox.read_inputdata import smashmodel
+
+import pyhdf5_handler
+import copy
+
+
+class model:
+    """Main class model() which has a complete set of functions, class and attributes to
+    build, run and manipulate the Smash model, compute statistical criterium and
+    plot graphics."""
+
+    def __init__(self, myparam):
+
+        self._myparam = copy.deepcopy(myparam)
+        """The attribute _myparam is a copy of the parent class smashbox.myparam.
+        This class stores the main parameters used for building the Smash model"""
+
+        self.mysetup = setup.setup(self._myparam.param)
+        """The attribute mysetup own the class setup.setup(). This class stores the Smash
+        setup for the hydrological simulation and some helpers to manipulate these
+        parameters."""
+
+        self.mymesh = mesh.mesh()
+        """The attribute mymesh own the class mesh.mesh(). This class stores the Smash
+        mesh used for the hydrological simulation and some helpers to manipulate this mesh.
+        """
+
+        self.mysmashmodel = None
+        """The attribute mysmashmodel stores the Smash model object created with
+        attributes mysetup and -mymesh."""
+
+        self._fstates = None
+        self._istates = None
+        self._myatmos_data_connector = None
+
+        self.warmup_model = None
+        """The attribute warmup_model store a smash model used for warmup and compatible 
+        with the model in attribute mysmashmodel"""
+
+        self.extra_smash_results = None
+        """The attribute extra_smash_results stores the extra results provided by Smash
+        if the parameter return_option is defined."""
+
+        self.mystats = mystats.mystats(self)
+        """The attribute mystats own the class mystats.mystats(). This class stores
+        statistical functions and results which could be applied on the smash model."""
+
+        self.myplot = myplot.myplot(self)
+        """The attribute myplot own the class myplot.myplot(). This class stores plotting
+        capabilities on the smash model object."""
+
+    def generate_mesh(
+        self,
+        max_surf: float | None = None,
+        min_surf: float | None = None,
+        max_depth: float = 1.0,
+        query: str | None = None,
+        area_error_th: None | float = None,
+    ):
+        """
+        Generate the mesh of the Smash model
+
+        Parameters
+        ----------
+
+        max_depth : `int`, default 1
+            The maximum depth accepted by the algorithm to find the catchment outlet.
+            A **max_depth** of 1 means that the algorithm will search among the
+            combinations in
+            (``row - 1``, ``row``, ``row + 1``; ``col - 1``, ``col``, ``col + 1``),
+            the coordinates that minimize
+            the relative error between the given catchment area and the modeled
+            catchment area calculated from the
+            flow directions file.
+        :param query: Any pandas dataframe query as string: '(SURF>20) & (SURF<100)'. This query
+        must be build using the field (column name) in the outlet database.
+        https://pandas.pydata.org/docs/user_guide/indexing.html#the-query-method
+        :type query: str
+        area_error_th: float | None
+            The tolerance error for the difference between the observed and simulated
+             surface. The error is computed as follow:
+                 Serror=abs(Ssim-Sobs)/Sobs
+            All outlets where `Serror > area_error_th` will be automatically removed from
+            the mesh.
+
+        Examples
+        --------
+
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("RealCollobrier")
+        >>> sb.RealCollobrier.generate_mesh(min_surf=5, max_surf=100)
+
+        """
+        self.mymesh.generate_mesh(
+            self._myparam.param,
+            max_depth=max_depth,
+            query=query,
+            area_error_th=area_error_th,
+        )
+
+    # @tools.auto_check_int
+    # def test(self, a: int = 1):
+    #     if isinstance(a, int):
+    #         print(f"a is int: {a}")
+    #     else:
+    #         print(f"a  is not int: {a}")
+
+    def model(self, setup: dict | None = None, mesh: dict | None = None):
+        """
+        Smash model object creation. This function wrap smash.Model(). Setup and mesh
+        argument are optional since these dictionnary are hosted by the smashbox object.
+
+        Parameters
+        ----------
+        setup: dict | None
+            The Smash setup (optionnal), if None the smashbox setup will be used
+        mesh: dict | None
+            The Smash mesh (optionnal), if None the smashbox mesh will be used
+
+        Examples
+        --------
+
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("RealCollobrier")
+        >>> sb.RealCollobrier.generate_mesh(run=False)
+        >>> sb.RealCollobrier.model()
+
+        """
+        if setup is None:
+            setup = self.mysetup.setup
+
+        if mesh is None:
+            mesh = self.mymesh.mesh
+
+        self.mysmashmodel = self._model(setup=setup, mesh=mesh)
+
+        self._gathering_atmosdata()
+
+        self._gathering_parameters(self.mysmashmodel)
+
+    def _model(self, setup=None, mesh=None):
+        """
+        Smash model object creation. This function wrap smash.Model()
+
+        Parameters
+        ----------
+        setup: dict | None
+            The Smash setup (optionnal), if None the smashbox setup will be used
+        mesh: dict | None
+            The Smash mesh (optionnal), if None the smashbox mesh will be used
+
+        Examples
+        --------
+
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("RealCollobrier")
+        >>> sb.RealCollobrier.generate_mesh(run=False)
+        >>> sb.RealCollobrier.model()
+
+        """
+        if setup is None:
+            print("</> The input setup is None ")
+            return None
+
+        if mesh is None:
+            print("</> input mesh is None. use smashbox.model.model.generate_mesh()")
+            return None
+
+        if self._myparam.param.enhanced_smash_input_data:
+            model = smashmodel.SmashModel(setup, mesh)
+        else:
+            model = smash.Model(setup, mesh)
+
+        return model
+
+    def _gathering_parameters(self, model):
+
+        if hasattr(self, "optimize_model") and self.optimize_model is not None:
+            print(f"</> Getting parameters from previously optimized model ...")
+            model.rr_parameters = self.optimize_model.rr_parameters
+        else:
+            print(
+                f"</> Importing parameters from {self._myparam.param._smash_parameters} ..."
+            )
+            self.import_parameters(model=model)
+            self._transform_parameters(
+                model=model, dt_origin=self._myparam.param._smash_parameters_dt
+            )
+
+    def _transform_parameters(self, model=None, dt_origin: None | float = None):
+        """
+        Function to transform the parameters according the model time-step and the original
+        time-step used for calibrated the parameters.
+        :param dt_origin: Original time-step used for generate the calibrated parameter,
+        defaults to None
+        :type dt_origin: None | float, optional
+
+        """
+        # if dt_origin is None:
+        #     raise ValueError(
+        #         " Argument dt_origin is None. This must be filled with the value "
+        #         "of the timestep used to calibrate the parameters."
+        #     )
+
+        # if not hasattr(self, "mysmashmodel") or self.mysmashmodel is None:
+        #     raise ValueError(
+        #         "</> mysmashmodel attribute does not exist or is None. "
+        #         "The model must be created first..."
+        #     )
+        if model is None:
+            return
+
+        dt_target = model.setup.dt
+
+        if dt_origin is None:
+            return
+
+        if dt_target == dt_origin:
+            return
+
+        print(
+            f"</> Tranforming parameters `ct`, `kexec`, `llr` calibrated with a time-step "
+            f"of {dt_origin}s to the modeled time-step {dt_target}s."
+        )
+        parameters_tranfsorm = ["ct", "kexc", "llr"]
+        power_tranform = [1.0 / 4.0, -1.0 / 8.0, 1.0]
+
+        for i, param in enumerate(parameters_tranfsorm):
+            index_param = np.where(param == model.rr_parameters.keys)[0]
+            if len(index_param) > 0:
+                model.rr_parameters.values[:, :, index_param[0]] = (
+                    model.rr_parameters.values[:, :, index_param[0]]
+                    * (dt_origin / dt_target) ** power_tranform[i]
+                )
+
+    def _gathering_atmosdata(self):
+
+        if self._myatmos_data_connector is not None:
+
+            print("</> Gathering atmos data ...")
+
+            if (
+                self._myatmos_data_connector.input_ntimestep
+                != self.mysmashmodel.setup.ntime_step
+            ):
+                print(
+                    "</> Warnings: Inconsistant ntime_step "
+                    f"{self._myatmos_data_connector.input_ntimestep}"
+                    f"!={self.mysmashmodel.setup.ntime_step}, "
+                    "the Smash model will be rebuild."
+                )
+
+                self._model()
+                self._gathering_parameters(self.mysmashmodel)
+
+            if self._myatmos_data_connector.smash_prcp is not None:
+                self.mysmashmodel.atmos_data.prcp = (
+                    self._myatmos_data_connector.smash_prcp
+                )
+
+            if self._myatmos_data_connector.smash_pet is not None:
+                self.mysmashmodel.atmos_data.pet = self._myatmos_data_connector.smash_pet
+
+            if self.mysmashmodel.setup.prcp_partitioning:
+                print("</> Compute prcp partitionning ...")
+                smash.fcore._mw_atmos_statistic.compute_prcp_partitioning(
+                    model.setup, model.mesh, model._input_data
+                )
+
+            if self.mysmashmodel.setup.compute_mean_atmos:
+                print("</> Computing mean atmospheric data")
+                smash.fcore._mw_atmos_statistic.compute_mean_atmos(
+                    self.mysmashmodel.setup,
+                    self.mysmashmodel.mesh,
+                    self.mysmashmodel._input_data,
+                )
+
+    @tools.autocast_args
+    def model_warmup(self, warmup: int = 365):
+        """
+        Smash model warmup function. This function warm the curent model by creating a new
+        on with attribute warmup_model. The final states of warmup_model are copied to the
+        initial states of mysmashmodel.
+
+        Parameters
+        ----------
+
+        warmup: None | int
+            a integer of the number of days used for warming the model.
+
+        """
+        print("</> Warmup the Smash-model...")
+
+        if warmup is not None:
+            try:
+                timedelta = datetime.timedelta(days=warmup)
+            except:
+                raise ValueError(f"warmup arg `{warmup}` is not a valid time delta.")
+
+            w_setup = copy.deepcopy(self.mysetup.setup)
+
+            w_setup["end_time"] = w_setup["start_time"]
+            w_setup["start_time"] = datetime.datetime.strftime(
+                datetime.datetime.fromisoformat(w_setup["start_time"]) - timedelta,
+                "%Y-%m-%d %H:%M",
+            )
+            w_setup["read_qobs"] = False
+            w_setup["read_prcp"] = True
+            w_setup["read_pet"] = True
+
+            self.warmup_model = self._model(setup=w_setup, mesh=self.mymesh.mesh)
+            self._gathering_parameters(self.warmup_model)
+            self.warmup_model.forward_run()
+
+            # TODO FIX BUG IN SMASH when states > 1.0
+            mask_sup = np.where(self.warmup_model.rr_final_states.values > 1)
+            self.warmup_model.rr_final_states.values[mask_sup] = 0.9999
+
+            if hasattr(self, "mysmashmodel") and self.mysmashmodel is not None:
+
+                self.mysmashmodel.rr_initial_states = self.warmup_model.rr_final_states
+
+    def optimize(
+        self,
+        start_time: None | str = None,
+        end_time: None | str = None,
+        mapping: str = "uniform",
+        optimizer: None | str = None,
+        optimize_options: None | str = None,
+        cost_options: None | str = None,
+        common_options: None | str = None,
+        return_options: None | str = None,
+        callback=None,
+    ):
+        """
+        Optimize the current model (with the current setup and mesh),
+        store the model in the attribute optimize_model and set the calibrated
+        parameters to the model behind the attribute mysmashmodel.
+        Start_time and end_time can be specified here to change the period of the
+        calibration compare to the current setup. All other arguments are
+        equivalent to the smash.model.optimize function
+        (see https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.optimize.html#smash.optimize).
+         One difference from Smash is that gauges with no data are
+         automatically removed from the optimization without raising an error.
+         This provide a convient way to calibrate quickly the parameters using the current
+         mesh which may include gauges with data for calibration
+         and location gauge for discharges computation.
+
+        :param start_time: The start time of the optimization, format "YYYY-mm-dd HH:MM", defaults to None
+        :type start_time: None | str, optional
+        :param end_time: The end time of the optimization, format "YYYY-mm-dd HH:MM", defaults to None
+        :type end_time: None | str, optional
+        :param mapping: Type of mapping, see https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.optimize.html#smash.optimize, defaults to "uniform"
+        :type mapping: str, optional
+        :param optimizer: Name of optimizer, see https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.optimize.html#smash.optimize, defaults to None
+        :type optimizer: None | str, optional
+        :param optimize_options: Dictionary containing optimization options for fine-tuning the optimization process, see https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.optimize.html#smash.optimize, defaults to None
+        :type optimize_options: None | str, optional
+        :param cost_options: Dictionary containing computation cost options for simulated and observed responses. see https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.optimize.html#smash.optimize, defaults to None
+        :type cost_options: None | str, optional
+        :param common_options: Dictionary containing common options with two elements: ncpu (int, default 1) and verbose (bool, default is False), defaults to None
+        :type common_options: None | str, optional
+        :param return_options: Dictionary containing return options to save additional simulation results, see https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.optimize.html#smash.optimize, defaults to None
+        :type return_options: None | str, optional
+        :param callback: A callable called after each iteration with the signature callback(iopt: Optimize), see https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.optimize.html#smash.optimize, defaults to None
+        :type callback: TYPE, optional
+
+        """
+        o_setup = copy.deepcopy(self.mysetup.setup)
+
+        if start_time is not None and end_time is not None:
+            o_setup["start_time"] = start_time
+            o_setup["end_time"] = end_time
+
+        o_setup["read_qobs"] = True
+        o_setup["read_prcp"] = True
+        o_setup["read_pet"] = True
+
+        self.optimize_model = self._model(setup=o_setup, mesh=self.mymesh.mesh)
+
+        default_cost_option = {"end_warmup": o_setup["start_time"], "gauge": "all"}
+        if cost_options is not None:
+            default_cost_option.update(cost_options)
+
+        # auto remove gauge if no observation
+        if isinstance(default_cost_option["gauge"], str):
+            if default_cost_option["gauge"] == "dws":
+                gauge = np.empty(shape=0)
+
+                for i, pos in enumerate(model.mesh.gauge_pos):
+                    if model.mesh.flwdst[tuple(pos)] == 0:
+                        gauge = np.append(gauge, self.optimize_model.mesh.code[i])
+
+            elif default_cost_option["gauge"] == "all":
+                gauge = np.array(self.optimize_model.mesh.code, ndmin=1)
+
+        # elif isinstance(gauge, (list, tuple, np.ndarray)):
+        #     gauge_bak = np.array(gauge, ndmin=1)
+        #     gauge = np.empty(shape=0)
+
+        #     for ggc in gauge_bak:
+        #         if ggc in self.optimize_model.mesh.code:
+        #             gauge = np.append(gauge, ggc)
+        #         else:
+        #             raise ValueError(
+        #                 f"Unknown gauge code '{ggc}' in gauge cost_options. Choices: {list(model.mesh.code)}"
+        #             )
+
+        st = pd.Timestamp(self.optimize_model.setup.start_time)
+        et = pd.Timestamp(self.optimize_model.setup.end_time)
+        ew = pd.Timestamp(default_cost_option["end_warmup"])
+        start_slice = int((ew - st).total_seconds() / self.optimize_model.setup.dt)
+        end_slice = int((et - ew).total_seconds() / self.optimize_model.setup.dt)
+        time_slice = slice(start_slice, end_slice)
+
+        del_gauge = []
+        for i in range(len(gauge)):
+
+            if np.all(self.optimize_model.response_data.q[i, time_slice] < 0):
+                del_gauge.append(i)
+
+                print(
+                    f"No observed discharge available at gauge '{gauge[i]}' for the selected "
+                    f"optimization period ['{ew}', '{et}']. This gauge is removed "
+                    f"from the optimization."
+                )
+
+        gauge = np.delete(gauge, del_gauge)
+        default_cost_option.update({"gauge": gauge})
+
+        self.optimize_model.optimize(
+            mapping,
+            optimizer,
+            optimize_options,
+            default_cost_option,
+            common_options,
+            return_options,
+            callback,
+        )
+
+        if hasattr(self, "mysmashmodel") and self.mysmashmodel is not None:
+            self.mysmashmodel.rr_parameters = self.optimize_model.rr_parameters.copy()
+
+    @tools.autocast_args
+    def forward_run(
+        self,
+        warmup: int | None = None,
+        invert_states: bool | None = False,
+        cost_options: dict | None = None,
+        common_options: dict | None = None,
+        return_options: dict | None = None,
+    ):
+        """
+        Smash model forward run.This function wrap smash.model.forward_run().
+
+        Parameters
+        ----------
+
+        warmup: None | int
+            a integer of the number of days used for warming the model.
+        invert_states : bool = False
+            invert states of the model, so that the final states are used
+            for the initial states.
+        cost_options : dict | None,
+            Dictionary containing computation cost options for simulated and observed responses (https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.Model.forward_run.html).
+        common_options: dict| None,
+            Dictionary containing common options with two elements, ncpu and verbose (https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.Model.forward_run.html)
+        return_options : dict | None,
+            Dictionary containing return options to save additional simulation results. (https://smash.recover.inrae.fr/api_reference/principal_methods/smash/smash.Model.forward_run.html)
+
+        Examples
+        --------
+
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("RealCollobrier")
+        >>> sb.RealCollobrier.generate_mesh(run=False)
+        >>> sb.RealCollobrier.model()
+        >>> sb.RealCollobrier.forward_run()
+        """
+
+        if self.mysmashmodel is None:
+            self.model()
+
+        if warmup is not None:
+            self.model_warmup(warmup=warmup)
+
+        if self.warmup_model is not None:
+            self.mysmashmodel.rr_initial_states = self.warmup_model.rr_final_states
+
+        if hasattr(self, "optimize_model"):
+            self.mysmashmodel.rr_parameters = self.optimize_model.rr_parameters
+
+        # needed here inorder to replace the rainfall without rebuild the model
+        self._gathering_atmosdata()
+
+        if invert_states:
+            if self._fstates is not None and not np.all(self._fstates == -99.0):
+
+                # TODO FIX BUG IN SMASH when states > 1.0
+                mask_inf = np.where(self.mysmashmodel.mesh.active_cell == 1)
+                mask_sup = np.where(self._fstates > 1)
+                self._fstates[mask_sup] = 0.9999
+
+                self.mysmashmodel.rr_initial_states.values[mask_inf] = self._fstates[
+                    mask_inf
+                ].copy()
+
+            else:
+                print(
+                    "</> model final states does not exist."
+                    " Invert states is not possible."
+                    " Smash default initial states is used."
+                )
+
+        self.extra_smash_results = self.mysmashmodel.forward_run(
+            cost_options=cost_options,
+            common_options=common_options,
+            return_options=return_options,
+        )
+
+        # states backup
+        self._fstates = self.mysmashmodel.rr_final_states.values.copy()
+        self._istates = self.mysmashmodel.rr_initial_states.values.copy()
+
+    @tools.autocast_args
+    def atmos_data_connector(
+        self,
+        input_prcp: np.ndarray | None = None,
+        input_pet: np.ndarray | None = None,
+        input_dt: float | None = None,
+        input_res: tuple | list = (1000.0, 1000.0),
+        input_start_time: str = "2050-01-01 01:00",
+        input_bbox: dict | None = None,
+        input_epsg: int = 2154,
+        resampling_method="home_made_with_scipy_zoom",
+    ):
+        """
+        Generate a connector for the external atmos_data comming from
+        other model such as Graffas (spatial rainfall generator).
+
+        Parameters
+        ----------
+
+        input_prcp : np.ndarray | None = None
+            An np.ndarray with shape (nrow, ncol, npdt) wich stores the spatial rainfall
+            which will be used by Smash.Ideally, the extend of this array match
+            exactlly the extend of the Smash domain.
+        input_pet : np.ndarray | None = None
+            An np.ndarray with shape (nrow, ncol, npdt) wich stores the spatial
+            evapotranspiration which will be used by Smash.
+        input_dt : float = 3600.
+            Time step in seconds of the input precipitation
+        input_res : tuple | list = (1000., 1000.)
+            The resolution of the input precipitation
+        input_start_time : str = "2050-01-01 01:00"
+            The date of the start_time
+        input_bbox : dict | None = None
+            The extend of the domain using a bbox.
+            The convention used here is a dictionary like
+            bbox={"left":xmin, "top": ymax, "right": xmax, "bottom": ymin}.
+            If not provided, the extend of the smash domain will be used starting
+            from xmin and ymin.
+        input_epsg : int = 2154
+            The epsg code of the coordinate system. If not provided,
+            the coordinate system used in Smash will be used.
+        resampling_method: str
+            The method to use to resample and crop the input array. Default is
+            'home_made_with_scipy_zoom' Choice are:
+            ['rasterio_1', 'rasterio_2', 'home_made_with_scipy_zoom'].
+            'home_made_with_scipy_zoom' is the fastest method. 'rasterio_1'
+            is the slowest method. However, 'rasterio' method use much tested and
+            reliable method to resample and crop the array.
+
+        Examples
+        --------
+
+        >>> prcp_array=np.zeros(200,200,20)+1.
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("RealCollobrier")
+        >>> sb.RealCollobrier.generate_mesh()
+        >>> sb.RealCollobrier.atmos_data_connector(input_prcp=prcp_array)
+
+        """
+        if input_prcp is None and input_pet is None:
+            raise ValueError(
+                "</> input_prcp and input_pet are None. input_prcp or input_pet must be"
+                " numpy.ndarray with shape (nrow, ncol, ntimesteps)."
+            )
+
+        if input_dt is None:
+            print(
+                "</> We suppose the input atmos data time-step equal to the model time-step."
+            )
+            input_dt = self.mysetup.setup["dt"]
+
+        if input_dt != self.mysetup.setup["dt"]:
+            print(
+                "</> Model and input atmos data have different time-step. "
+                "Input atmos data will be resampled."
+            )
+            if input_prcp is not None:
+                input_prcp = tools.time_resample_prcp_array(
+                    input_prcp,
+                    input_dt,
+                    self.mysetup.setup["dt"],
+                    t_axis=2,
+                )
+            if input_pet is not None:
+                input_pet = tools.time_resample_prcp_array(
+                    input_pet,
+                    input_dt,
+                    self.mysetup.setup["dt"],
+                    t_axis=2,
+                )
+            input_dt = self.mysetup.setup["dt"]
+
+        # use conversion factor defined in setup
+        if "prcp_conversion_factor" in self.mysetup.setup and input_prcp is not None:
+            input_prcp = input_prcp * self.mysetup.setup["prcp_conversion_factor"]
+        if "pet_conversion_factor" in self.mysetup.setup and input_pet is not None:
+            input_pet = input_pet * self.mysetup.setup["pet_conversion_factor"]
+
+        self._myatmos_data_connector = atmos_data_connector.atmos_data_connector(
+            input_prcp=input_prcp,
+            input_pet=input_pet,
+            input_dt=input_dt,
+            input_res=input_res,
+            input_start_time=input_start_time,
+            input_bbox=input_bbox,
+            input_epsg=input_epsg,
+        )
+
+        smash_bbox = geo_toolbox.get_bbox_from_smash_mesh(self.mymesh.mesh)
+
+        self._myatmos_data_connector.read_input_atmos_data(
+            output_bbox=smash_bbox,
+            output_epsg=self._myparam.param.epsg,
+            output_res=(self.mymesh.mesh["xres"], self.mymesh.mesh["yres"]),
+            output_shape=(self.mymesh.mesh["nrow"], self.mymesh.mesh["ncol"]),
+            resampling_method=resampling_method,
+        )
+
+        self._myatmos_data_connector.change_setup(self.mysetup)
+
+    def import_parameters(self, model=None):
+        """
+        Import Geotiff parameter in Smash. This function wrap
+        smash.io.import_parameters(). Path to the parameters is defined in
+        self._myparam.param.smash_parameters.
+
+        Parameter
+        ---------
+
+        model: smash.Model object
+            A Smash model object. If None, the Smash model of smashbox will be used
+
+        Examples
+        --------
+
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("RealCollobrier")
+        >>> sb.RealCollobrier.generate_mesh(run=False)
+        >>> sb.RealCollobrier.model()
+        >>> sb.RealCollobrier.import_parameters()
+        >>> sb.RealCollobrier.forward_run()
+        """
+        if self._myparam.param.smash_parameters is None:
+            print(
+                "</> Warning: no calibrated Smash parameters is used, leaving it to"
+                "  default."
+            )
+            return
+
+        if model is None:
+            model = self.mysmashmodel
+
+        smash.io.import_parameters(
+            model=model,
+            path_to_parameters=self._myparam.param.smash_parameters,
+        )
+
+    def export_parameters(self, path: os.PathLike = "./output_smash_param"):
+        """
+        Export Geotiff Smash parameter as Geotiff. This function wrap
+        smash.io.export_parameters().
+
+        Parameters
+        ----------
+
+        path : os.PathLike = "./output_smash_param"
+            path to a directory where the parameter will be saved.
+
+        Examples
+        --------
+
+        >>> es=smashbox.SmashBox()
+        >>> sb.newmodel("RealCollobrier")
+        >>> sb.RealCollobrier.generate_mesh(run=False)
+        >>> sb.RealCollobrier.model()
+        >>> sb.RealCollobrier.import_parameters()
+        >>> sb.RealCollobrier.export_parameters()
+        """
+        smash.io.export_parameters(self.mysmashmodel, path)
+
+    def save_model_container(
+        self, path_to_hdf5: str | None = None, save_smash_model: bool = True
+    ):
+        """
+
+        :param path_to_hdf5: Path to the hdf5 file, defaults to None. If None,
+        the fucntion will return a dictionnary containing all data of the self object.
+        :type path_to_hdf5: str | None, optional
+        :param save_smash_model: Savec the smash models objects or no, defaults
+        to True. If False the Smash models objects are not saved.
+        :type save_smash_model: str, optional
+        :return: if a path_to_hdf5 is None, a dictionary containing all
+        attribute of the input object self is returned.
+        :rtype: dict | None
+
+        """
+
+        if path_to_hdf5 is not None:
+
+            structure = pyhdf5_handler.src.object_handler.generate_object_structure(
+                self, include_method=False
+            )
+
+            if not save_smash_model:
+                del structure["warmup_model"]
+                del structure["mysmashmodel"]
+
+            pyhdf5_handler.save_object_to_hdf5file(
+                path_to_hdf5=path_to_hdf5,
+                instance=self,
+                keys_data=structure,
+            )
+
+        else:
+            dict_results = pyhdf5_handler.src.object_handler.read_object_as_dict(self)
+
+            if not save_smash_model:
+                del dict_results["warmup_model"]
+                del dict_results["mysmashmodel"]
+
+            return dict_results
+
+    # def import_parameters(self)
+    # if os.path.exists(self._myparam.param.smash_parameters) and self._myparam.param.smash_parameters.endswith(".hdf5"):
+
+    #     hdf5= pyhdf5_handler.open_hdf5(self._myparam.param.smash_parameters)
+    #     hdf5_key=list(hdf5.keys())
+    #     hdf5.close()
+
+    #     if "model_ddt" in hdf5_key:
+    #         with_param = pyhdf5_handler.read_hdf5file_as_dict(self._myparam.param.smash_parameters,location="model_ddt/rr_parameters")
+    #         with_mesh = pyhdf5_handler.get_hdf5file_item(self._myparam.param.smash_parameters,location="model_ddt",item="mesh")
+
+    #         smash_parameters.transfert_params_to_model(
+    #             from_mesh=
+    #             with_mesh,
+    #             with_param=with_param,
+    #             to_model=self.mysmashmodel)
+
+    #     elif "model" in hdf5_key:
+    #         with_param = pyhdf5_handler.get_hdf5file_item(self._myparam.param.smash_parameters,location="model",item="rr_parameters")
+    #         with_mesh = pyhdf5_handler.get_hdf5file_item(self._myparam.param.smash_parameters,location="model",item="mesh")
+
+    #         smash_parameters.transfert_params_to_model(
+    #             from_mesh=
+    #             with_mesh,
+    #             with_param=with_param,
+    #             to_model=self.mysmashmodel)
+
+    #     elif "rr_parameters" in hdf5.keys() and "mesh" in hdf5.keys():
+    #         with_param = pyhdf5_handler.get_hdf5file_item(self._myparam.param.smash_parameters,location="./",item="rr_parameters")
+    #         with_mesh = pyhdf5_handler.get_hdf5file_item(self._myparam.param.smash_parameters,location="./",item="mesh")
+
+    #         smash_parameters.transfert_params_to_model(
+    #             from_mesh=with_mesh,
+    #             with_param=with_param,
+    #             to_model=self.mysmashmodel)
+
+    #     else:
+    #         raise ValueError("</> Error: cannot load the parameters ... unknown format...")
+
+    # elif os.path.isdir(self._myparam.param.smash_parameters):
+
+    #     smash_parameters.load_param_from_tiffformat(model=self.mysmashmodel, path_to_parameters=self._myparam.param.smash_parameters)
+
+    # else:
+    #     raise ValueError(f"</> Error: cannot load the parameters. Path or file '{self._myparam.param.smash_parameters}' does not exist ... ")
+
+    # def write_smashparam(self, hdf5file : str | os.PathLike = "output_smash_param.hdf5"):
+
+    #     rr_parameters=pyhdf5_handler.read_object_as_dict(self.mysmashmodel.rr_parameters)
+    #     pyhdf5_handler.save_dict_to_hdf5(hdf5file, rr_parameters)
+
+    # def export_parameters(self, path : os.path = "./output_smash_param")
+
+    # list_param=list(self.mysmashmodel.rr_parameters.keys)
+
+    # for smparam in list_param:
+
+    #     array=self.mysmashmodel.rr_parameters.values[:,:,list_param.index(smparam)]
+
+    #     smash_parameters.write_array_to_geotiff(os.path.join(path, smparam+".tif"),
+    #                            array,
+    #                            self.mysmashmodel.mesh.xmin,
+    #                            self.mysmashmodel.mesh.ymax,
+    #                            output_res = (self.mymesh.mesh["xres"],
+    #                                          self.mymesh.mesh["yres"])
+    #                            )