smashbox 1.0__py2.py3-none-any.whl

smashbox/model/atmos_data_connector.py

@@ -0,0 +1,518 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jul 15 10:39:36 2025
+
+@author: maxime
+"""
+
+import numpy as np
+import datetime
+import rasterio
+from rasterio.transform import from_origin
+from rasterio.io import MemoryFile
+from rasterio.enums import Resampling
+from rasterio.warp import reproject
+from rasterio.windows import from_bounds
+
+from tqdm import tqdm
+
+from smashbox.tools import geo_toolbox
+
+
+class atmos_data_connector:
+    """Class atmos_data_connector. This class handle external atmos data (precipitation
+    and potential evapotranspiration) provider. Precipiation and evapotranspiration
+    can be provided to Smash as a numpy.ndarray. This class has some functions to read
+    and crop the array."""
+
+    def __init__(
+        self,
+        input_prcp: np.ndarray | None = None,
+        input_pet: np.ndarray | None = None,
+        input_dt: float = 3600.0,
+        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,
+    ):
+        """
+
+        :param input_prcp: Matrix of shape (nbx, nby, nbts) of the precipitation,
+         defaults to None
+        :type input_prcp: np.ndarray | None, optional
+        :param input_pet: Matrix of shape (nbx, nby,nbts) of the evapotranspiration,
+        defaults to None
+        :type input_pet: np.ndarray | None, optional
+        :param input_dt: Time step of the input atmos data in seconds, defaults to 3600.0
+        :type input_dt: float, optional
+        :param input_res: Resolution of the input data in meters, tuple or list of the
+         corresponding resolution in x and y direction, defaults to (1000.0, 1000.0)
+        :type input_res: tuple | list, optional
+        :param input_start_time: The custom start time of the input atmos data chronicle,
+         defaults to "2050-01-01 01:00"
+        :type input_start_time: str, optional
+        :param input_bbox: The bbox of the input atmos data, defaults to None. if None,
+        the bbox of the Smash model is used and the left bottom corner of the matrix is
+        positionned according the smash bbox.
+        :type input_bbox: dict | None, optional
+        :param input_epsg: The Epsg code of the input bbox coordinate, defaults to 2154
+        :type input_epsg: int, optional
+
+        """
+
+        self.input_prcp = input_prcp
+        """Input precipiation matrix. np.ndarray of shape (nbx,nby,nbts)."""
+        self.input_pet = input_pet
+        """Input evapotranspiration matrix. np.ndarray of shape (nbx,nby,nbts)."""
+        self.input_res = input_res
+        """Input resolution of the atmos data matrix. tuple | list of the corresponding
+        resolution in the x and y direction (meters)"""
+        self.input_dt = input_dt
+        """Input time-step in seconds of the atmos data."""
+        self.input_bbox = input_bbox
+        """Input bounding box of the atmos data matrix. dictionnary
+        {'left':, 'right':,'top':,'bottom':}"""
+        self.input_epsg = input_epsg
+        """Input epsg code of the corresponding coordinates of the bounding box."""
+        self.input_start_time = None
+        """Custom start-time date of the chronicle."""
+        self.input_ntimestep = None
+        """Number of time-step of the chronicle."""
+
+        self.smash_prcp = None
+        """Cropped Smash precipitation matrix that will be copied into the Smash model."""
+        self.smash_pet = None
+        """Cropped PET matrix that will be copied into the Smash model."""
+        self.smash_start_time = None
+        """Futur Smash setup start-time"""
+        self.smash_end_time = None
+        """Futur Smash setup end_time"""
+
+        if input_prcp is not None:
+            self.get_ntimestep(input_data=input_prcp)
+            self.set_setup_datetime(input_dt=input_dt, input_start_time=input_start_time)
+
+        if input_pet is not None:
+            if input_pet.shape != input_prcp.shape:
+                raise ValueError(
+                    "The shape of input_pet and input_prcp must be the same."
+                )
+
+    def get_ntimestep(self, input_data: np.ndarray | None = None):
+        """
+        Compute the number of time-step of the input atmos data.
+        """
+
+        if input_data is not None:
+
+            if len(input_data.shape) != 3:
+                raise ValueError(
+                    "</> Input atmos data matrix 'input_data' must be an"
+                    "array of shape (nrow, ncol, n_time_step)."
+                )
+
+            self.input_ntimestep = input_data.shape[2]
+
+    def set_setup_datetime(
+        self, input_dt: float = 3600.0, input_start_time: str = "2050-01-01 01:00"
+    ):
+        """
+        Compute the start-time and end-time of the futur Smash simulation.
+
+        :param input_dt: The input time-step of the atmos-data in seconds,
+         defaults to 3600.0
+        :type input_dt: float, optional
+        :param input_start_time: The custom input-start time, defaults to "2050-01-01 01:00"
+        :type input_start_time: str, optional
+
+        """
+
+        if self.input_ntimestep is None:
+            raise ValueError(
+                "</> self.input_ntimestep is None. Use self.get_ntimestep() first."
+            )
+
+        end_time = datetime.datetime.fromisoformat(input_start_time) + datetime.timedelta(
+            seconds=input_dt * self.input_ntimestep
+        )
+
+        self.smash_start_time = input_start_time
+        self.smash_end_time = end_time.strftime("%Y-%m-%d %H:%M")
+
+    def change_setup(self, mysetup):
+        """
+        Change the properties of the setup.mysetup() class.
+        :param mysetup: Class setup.mysetup()
+        :type mysetup: TYPE
+
+        """
+        mysetup.set_setup("start_time", self.smash_start_time)
+        mysetup.set_setup("end_time", self.smash_end_time)
+        mysetup.set_setup("read_qobs", False)
+
+        if self.input_prcp is not None:
+            mysetup.set_setup("read_prcp", False)
+
+        if self.input_pet is not None:
+            mysetup.set_setup("read_pet", False)
+
+    def read_input_atmos_data(
+        self,
+        output_bbox: dict = None,
+        output_epsg: int = 2154,
+        output_res: tuple | list = (1000.0, 1000.0),
+        output_shape: tuple | list = (-99, -99),
+        resampling_method: str = "home_made_with_scipy_zoom",
+    ):
+        """
+        Read, crop and resample input atmos_data if required. Three methods are provided
+        with options resampling_method.
+        :param output_bbox: The output bounding box of the matrix, defaults to None
+        :type output_bbox: dict, optional
+        :param output_epsg: The output EPSG code of the coordinates, defaults to 2154
+        :type output_epsg: int, optional
+        :param output_res: The output resolution of the atmos data matrix,
+        defaults to (1000.0, 1000.0)
+        :type output_res: tuple | list, optional
+        :param output_shape: The ouput shape of the atmosdata matrix.
+        If output_shape and output_bbox are provided and if the input atmos_data matrix
+         matches these characteritics, the resampling is skipped (much faster).
+          Defaults to (-99, -99)
+        :type output_shape: tuple | list, optional
+        :param resampling_method: The resampling method to use, choice are rasterio_1,
+        rasterio_2 and , home_made_with_scipy_zoom. Defaults to "home_made_with_scipy_zoom"
+        :type resampling_method: str, optional
+
+        """
+
+        if resampling_method == "rasterio_1":
+            if self.input_prcp is not None:
+                array = self.read_input_data(
+                    self.input_prcp,
+                    output_bbox=output_bbox,
+                    output_epsg=output_epsg,
+                    output_res=output_res,
+                    output_shape=output_shape,
+                )
+                self.smash_prcp = array
+
+            if self.input_pet is not None:
+                array = self.read_input_data(
+                    self.input_pet,
+                    output_bbox=output_bbox,
+                    output_epsg=output_epsg,
+                    output_res=output_res,
+                    output_shape=output_shape,
+                )
+                self.smash_pet = array
+
+        elif resampling_method == "rasterio_2":
+            if self.input_prcp is not None:
+                array = self.read_input_data2(
+                    self.input_prcp,
+                    output_bbox=output_bbox,
+                    output_epsg=output_epsg,
+                    output_res=output_res,
+                    output_shape=output_shape,
+                )
+
+                self.smash_prcp = array
+
+            if self.input_pet is not None:
+                array = self.read_input_data2(
+                    self.input_pet,
+                    output_bbox=output_bbox,
+                    output_epsg=output_epsg,
+                    output_res=output_res,
+                    output_shape=output_shape,
+                )
+                self.smash_pet = array
+
+        elif resampling_method == "home_made_with_scipy_zoom":
+            if self.input_prcp is not None:
+                array = self.read_input_data3(
+                    self.input_prcp,
+                    output_bbox=output_bbox,
+                    output_epsg=output_epsg,
+                    output_res=output_res,
+                    output_shape=output_shape,
+                )
+                self.smash_prcp = array
+
+            if self.input_pet is not None:
+                array = self.read_input_data3(
+                    self.input_pet,
+                    output_bbox=output_bbox,
+                    output_epsg=output_epsg,
+                    output_res=output_res,
+                    output_shape=output_shape,
+                )
+                self.smash_pet = array
+
+    def read_input_data(
+        self,
+        input_data: np.ndarray | None,
+        output_bbox: dict = None,
+        output_epsg: int = 2154,
+        output_res: tuple | list = (1000.0, 1000.0),
+        output_shape: tuple | list = (-99, -99),
+    ):
+        """
+        Read, crop and resample an input matrix. Use Rasterio MemoryFile and
+         Rasterio reproject function. Slowest method.
+        :param input_data: Input data as a matrix np.ndarray with shape (nbx,nby,nbts)
+        :type input_data: np.ndarray | None
+        :param output_bbox: The output bounding box of the matrix, defaults to None
+        :type output_bbox: dict, optional
+        :param output_epsg: The output EPSG code of the coordinates, defaults to 2154
+        :type output_epsg: int, optional
+        :param output_res: The output resolution of the atmos data matrix,
+        defaults to (1000.0, 1000.0)
+        :type output_res: tuple | list, optional
+        :param output_shape: The ouput shape of the atmosdata matrix.
+        If output_shape and output_bbox are provided and if the input atmos_data matrix
+         matches these characteritics, the resampling is skipped (much faster).
+          Defaults to (-99, -99)
+        :type output_shape: tuple | list, optional
+        :return: Array with shape ans resolution corresponding to the Smash model
+        :rtype: np.ndarray
+
+        """
+
+        height, width, ntimestep = input_data.shape
+        input_crs = f"EPSG:{self.input_epsg}"
+        output_crs = f"EPSG:{output_epsg}"
+
+        # Créer le transform (origine en haut à gauche, donc top et left)
+        if self.input_bbox is None:
+            print(
+                "</> Warning: no bbox or crs was provided with the graffas"
+                " prcp. We suppose the domain of the Graffas prcp equal to the"
+                " domain of the Smash mesh."
+            )
+            self.input_bbox = output_bbox
+
+        if (
+            sorted(self.input_bbox) == sorted(output_bbox)
+            and input_data.shape[0:2] == output_shape
+        ):
+            return input_data
+
+        transform = from_origin(
+            self.input_bbox["left"],
+            self.input_bbox["top"],
+            self.input_res[0],
+            self.input_res[1],
+        )
+
+        with MemoryFile() as memfile:
+            with memfile.open(
+                driver="GTiff",
+                height=height,
+                width=width,
+                count=self.input_ntimestep,
+                dtype=input_data.dtype,
+                transform=transform,
+                crs=input_crs,
+            ) as dataset:
+                print("</> Writing input data matrix in memory")
+                for t in tqdm(range(self.input_ntimestep)):
+                    dataset.write(input_data[:, :, t], t + 1)
+
+                new_width = int(
+                    (output_bbox["right"] - output_bbox["left"]) / output_res[0]
+                )
+                new_height = int(
+                    (output_bbox["top"] - output_bbox["bottom"]) / output_res[1]
+                )
+                new_transform = from_origin(
+                    output_bbox["left"], output_bbox["top"], output_res[0], output_res[1]
+                )
+
+                # # Créer un tableau cible pour les données re-projetées
+                new_array = np.empty(
+                    (self.input_ntimestep, new_height, new_width), dtype=np.float32
+                )
+
+                print("</>Reproject and resample input data matrix.")
+                for t in tqdm(range(self.input_ntimestep)):
+                    reproject(
+                        source=rasterio.band(dataset, t + 1),
+                        destination=new_array[t],
+                        src_transform=transform,
+                        src_crs=input_crs,
+                        dst_transform=new_transform,
+                        dst_crs=output_crs,
+                        resampling=Resampling.nearest,
+                    )
+
+        return np.transpose(new_array, axes=(1, 2, 0))
+        # self.smash_prcp=np.transpose(new_array,axes=(1,2,0))
+
+    def read_input_data2(
+        self,
+        input_data: np.ndarray | None,
+        output_bbox: dict = None,
+        output_epsg: int = 2154,
+        output_res: tuple | list = (1000.0, 1000.0),
+        output_shape: tuple | list = (-99, -99),
+    ):
+        """
+        Read, crop and resample an input matrix. Use Rasterio MemoryFile and
+         Rasterio read function for resampling.
+        :param input_data: Input data as a matrix np.ndarray with shape (nbx,nby,nbts)
+        :type input_data: np.ndarray | None
+        :param output_bbox: The output bounding box of the matrix, defaults to None
+        :type output_bbox: dict, optional
+        :param output_epsg: The output EPSG code of the coordinates, defaults to 2154
+        :type output_epsg: int, optional
+        :param output_res: The output resolution of the atmos data matrix,
+        defaults to (1000.0, 1000.0)
+        :type output_res: tuple | list, optional
+        :param output_shape: The ouput shape of the atmosdata matrix.
+        If output_shape and output_bbox are provided and if the input atmos_data matrix
+         matches these characteritics, the resampling is skipped (much faster).
+          Defaults to (-99, -99)
+        :type output_shape: tuple | list, optional
+        :return: Array with shape ans resolution corresponding to the Smash model
+        :rtype: np.ndarray
+
+        """
+
+        if input_data is None:
+            raise ValueError(
+                "</> self.input_data is None. Use grafas.grafas(input_data=np.array()) or"
+                " sb.model.graffas_connector(input_data=np.array()) "
+                "to upload precipitation."
+            )
+
+        height, width, ntimestep = input_data.shape
+        crs = f"EPSG:{self.input_epsg}"
+
+        if self.input_bbox is None:
+            print(
+                "</> Warning: no bbox or crs was provided with the graffas"
+                " prcp. We suppose the domain of the Graffas prcp equal to"
+                " the domain of the Smash mesh."
+            )
+            self.input_bbox = output_bbox
+
+        if (
+            sorted(self.input_bbox) == sorted(output_bbox)
+            and input_data.shape[0:2] == output_shape
+        ):
+            return input_data
+
+        transform = from_origin(
+            self.input_bbox["left"],
+            self.input_bbox["top"],
+            self.input_res[0],
+            self.input_res[1],
+        )
+
+        with MemoryFile() as memfile:
+            with memfile.open(
+                driver="GTiff",
+                height=height,
+                width=width,
+                count=self.input_ntimestep,
+                dtype=input_data.dtype,
+                transform=transform,
+                crs=crs,
+            ) as dataset:
+                for t in tqdm(range(self.input_ntimestep)):
+                    dataset.write(input_data[:, :, t], t + 1)
+
+                x_scale_factor = dataset.res[0] / output_res[0]
+                y_scale_factor = dataset.res[1] / output_res[1]
+
+                # resampling first to avoid spatial shifting of the parameters
+                prcp_resampled = dataset.read(
+                    out_shape=(
+                        dataset.count,
+                        int(dataset.height * y_scale_factor),
+                        int(dataset.width * x_scale_factor),
+                    ),
+                    resampling=Resampling.nearest,
+                )
+
+        # scale image transform
+        scaled_transform = dataset.transform * dataset.transform.scale(
+            (dataset.width / prcp_resampled.shape[-1]),
+            (dataset.height / prcp_resampled.shape[-2]),
+        )
+
+        # Get a window that corresponds to the smaller raster's bounds
+        window = from_bounds(**output_bbox, transform=scaled_transform)
+
+        prcp_cropped = np.transpose(
+            prcp_resampled[
+                :,
+                int(window.row_off) : int(window.row_off + window.height),
+                int(window.col_off) : int(window.col_off + window.width),
+            ],
+            axes=(1, 2, 0),
+        )
+        return prcp_cropped
+
+    def read_input_data3(
+        self,
+        input_data: np.ndarray | None,
+        output_bbox: dict = None,
+        output_epsg: int = 2154,
+        output_res: tuple | list = (1000.0, 1000.0),
+        output_shape: tuple | list = (-99, -99),
+    ):
+        """
+        Read, crop and resample an input matrix. Use home made functions to crop he array.
+        Use scipy zoom method for resampling.
+        :param input_data: Input data as a matrix np.ndarray with shape (nbx,nby,nbts)
+        :type input_data: np.ndarray | None
+        :param output_bbox: The output bounding box of the matrix, defaults to None
+        :type output_bbox: dict, optional
+        :param output_epsg: The output EPSG code of the coordinates, defaults to 2154
+        :type output_epsg: int, optional
+        :param output_res: The output resolution of the atmos data matrix,
+        defaults to (1000.0, 1000.0)
+        :type output_res: tuple | list, optional
+        :param output_shape: The ouput shape of the atmosdata matrix.
+        If output_shape and output_bbox are provided and if the input atmos_data matrix
+         matches these characteritics, the resampling is skipped (much faster).
+          Defaults to (-99, -99)
+        :type output_shape: tuple | list, optional
+        :return: Array with shape ans resolution corresponding to the Smash model
+        :rtype: np.ndarray
+
+        """
+        if self.input_bbox is None:
+            print(
+                "</> Warning: no bbox or crs was provided with the graffas"
+                " prcp. We suppose the domain of the Graffas prcp equal to the"
+                " domain of the Smash mesh."
+            )
+            self.input_bbox = output_bbox
+
+        if (
+            sorted(self.input_bbox) == sorted(output_bbox)
+            and input_data.shape[0:2] == output_shape
+        ):
+            return input_data
+
+        print("</> use 'home_made_with_scipy_zoom' to crop and resample the input array")
+        # # Créer un tableau cible pour les données re-projetées
+        new_array = np.empty((*output_shape, self.input_ntimestep), dtype=np.float32)
+
+        for t in tqdm(range(self.input_ntimestep)):
+            new_array[:, :, t] = geo_toolbox.crop_array(
+                input_data[:, :, t],
+                bbox_in=self.input_bbox,
+                res_in={"dx": self.input_res[0], "dy": self.input_res[1]},
+                bbox_out=output_bbox,
+                res_out={"dx": output_res[0], "dy": output_res[1]},
+                order=0,
+                cval=-99.0,
+                grid_mode=True,
+            )
+
+        return new_array

smashbox/model/mesh.py

@@ -0,0 +1,185 @@
+import smash
+import pandas as pd
+import geopandas as gpd
+import os
+import numpy as np
+from smashbox.init.param import smashboxparam
+
+
+class mesh:
+    """Class mesh(). This class has three functions and one attributes to generate, load,
+    write and store the mesh used by Smash."""
+
+    def __init__(self):
+        self.mesh = None
+        self.catchment_polygon = None
+
+    def write_mesh(self, filename: os.PathLike | None = None):
+        """
+        Write the mesh of the Smash model unsing hdf5 format.
+        :param filename: Path to the file where to write the mesh, defaults to None
+        :type filename: os.PathLike | None, optional
+
+        """
+        if filename is not None:
+            smash.io.save_mesh(self.mesh, path=filename)
+        else:
+            raise ValueError(f"Output filename '{filename}' is None.")
+
+    def load_mesh(self, filename: os.PathLike | None = None):
+        """
+        Read a mesh for Smash stored with the hdf5 format.
+        :param filename: path to the hdf5 file
+        :type filename: TYPE
+
+        """
+
+        if os.path.exists(filename):
+            self.mesh = smash.io.read_mesh(filename)
+        else:
+            raise ValueError(f"{filename} does not exist.")
+
+    def generate_mesh(
+        self,
+        param: smashboxparam | None = None,
+        query: str | None = None,
+        max_depth: float = 1.0,
+        area_error_th: None | float = None,
+    ):
+        """
+        :param param: Class param.smashboxparam(), store main smashbox parameters
+        :type param: param.smashboxparam()
+        :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
+        :max_depth: 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.
+        :type `int`, default 1
+        :param area_error_th: Tolerance error during the positionning of the outlets. If the Error `(Ssim-Sobs)/Sobs > area_error_th`, the outlet will be excluded.
+        :type area_error_th: float
+
+        """
+
+        if param.bbox is not None:
+            bbox = [
+                param.bbox["left"],
+                param.bbox["right"],
+                param.bbox["bottom"],
+                param.bbox["top"],
+            ]
+        else:
+            bbox = None
+
+        if not os.path.exists(param.outlets_database):
+            param.outlets_database = os.path.join(
+                param.asset_dir, "outlets", param.outlets_database
+            )
+
+        if os.path.exists(param.outlets_database):
+            stations_calage = pd.read_csv(param.outlets_database)
+        else:
+            raise ValueError(f"</> Error: file {param.outlets_database} not found")
+
+        if param.outletsID is not None:
+            if len(param.outletsID) > 0:
+                stations_calage = stations_calage.loc[
+                    stations_calage[param.outlets_database_fields["id"]].isin(
+                        param.outletsID
+                    )
+                ]
+
+            if query is not None:
+                stations_calage = stations_calage.query(query)
+
+            # selection par surface
+            # if max_surf is not None:
+            #     stations_calage = stations_calage[
+            #         stations_calage[param.outlets_database_fields["area"]] <= max_surf
+            #     ]
+
+            # if min_surf is not None:
+            #     stations_calage = stations_calage[
+            #         stations_calage[param.outlets_database_fields["area"]] >= min_surf
+            #     ]
+
+            if bbox is not None:
+                stations_calage = stations_calage[
+                    (
+                        stations_calage[param.outlets_database_fields["coord_x"]]
+                        >= param.bbox["left"]
+                    )
+                    & (
+                        stations_calage[param.outlets_database_fields["coord_x"]]
+                        <= param.bbox["right"]
+                    )
+                    & (
+                        stations_calage[param.outlets_database_fields["coord_y"]]
+                        >= param.bbox["bottom"]
+                    )
+                    & (
+                        stations_calage[param.outlets_database_fields["coord_y"]]
+                        <= param.bbox["top"]
+                    )
+                ]
+
+            if len(stations_calage) == 0:
+                print(
+                    f"</> Error: outlets {param.outletsID} not found in"
+                    "{param.outlets_database}"
+                )
+                raise ValueError(
+                    f"</> Error: outlets {param.outletsID} not found in"
+                    "{param.outlets_database}"
+                )
+
+            columns = {
+                "coord_x": param.outlets_database_fields["coord_x"],
+                "coord_y": param.outlets_database_fields["coord_y"],
+                "area": param.outlets_database_fields["area"],
+                "id": param.outlets_database_fields["id"],
+            }
+
+            self.mesh = smash.factory.generate_mesh(
+                flwdir_path=param.flowdir,
+                bbox=bbox,
+                x=np.array(stations_calage[columns["coord_x"]][:]),
+                y=np.array(stations_calage[columns["coord_y"]][:]),
+                area=np.array(
+                    stations_calage[columns["area"]][:] * 1e6
+                ),  # Convert km² to m²
+                code=np.array(stations_calage[columns["id"]][:]),
+                epsg=param.epsg,
+                shp_path=param.outlets_shapefile,
+                max_depth=max_depth,
+                area_error_th=area_error_th,
+            )
+
+            if param.outlets_shapefile is not None:
+                print("</> Outlets shapefile detected. Loading outlets ...")
+                catchment_polygon = gpd.read_file(param.outlets_shapefile)
+                self.catchment_polygon = catchment_polygon.loc[
+                    catchment_polygon.code.isin(
+                        # np.array(stations_calage[columns["id"]][:])
+                        self.mesh["code"]
+                    )
+                ]
+                del catchment_polygon
+
+        else:
+            stations_calage = pd.DataFrame(None)
+
+            if bbox is None:
+                raise ValueError(
+                    "Bbox is None. If no outlets provided, the bbox must be defined."
+                )
+
+            self.mesh = smash.factory.generate_mesh(
+                flwdir_path=param.flowdir, bbox=bbox, epsg=param.epsg, max_depth=max_depth
+            )