Tip

For an interactive online version click here:

Example: Working with mesh models

The main feature of HydroMT is to facilitate the process of building and analyzing spatial geoscientific models with a focus on water system models. It does so by automating the workflow to go from raw data to a complete model instance which is ready to run and to analyse model results once the simulation has finished.

This notebook will explore how to work with mesh models.

# import hydromt and setup logging
import hydromt
from hydromt.log import setuplog

# other imports
import matplotlib.pyplot as plt
import geopandas as gpd

logger = setuplog("working with mesh models", log_level=10)

2024-02-26 15:13:12,117 - working with mesh models - log - INFO - HydroMT version: 0.9.4

Check if mesh_model is available

To know which models are available within your active environment, you can use global MODELS variable in hydromt

# generic model classes
print(f"Generic model classes: {hydromt.MODELS.generic}")
# model classes from external plugin
print(f"Model classes from plugins: {hydromt.MODELS.plugins}")

Generic model classes: ['grid_model', 'vector_model', 'mesh_model', 'network_model']
Model classes from plugins: []

Here you may only see the generic models grid_model, vector_model and network_model. There is one more generic model within HydroMT mesh_model which is only available if the additional python mesh dependency xugrid is available in the activated environment. If not add xugrid to your environment.

Mesh component properties and preparation with setup_mesh2d method

The main component of MeshModel is the mesh object. The mesh object in HydroMT is defined using the UgridDataset object of the xugrid.

The mesh object is able to contain 1D, 2D and/or 3D unstructured grid(s) according to the UGRID conventions. Several grids are supported and each grid should have a name to be able to select or prepare data for a specific one.

Let’s have a look at an example of MeshModel.mesh and the available properties:

# Instantiate a mesh model
mod = hydromt.MeshModel(
    root="data/mesh_model",
    mode="r",
)
# Read the mesh
mod.read_mesh(fn='mesh1d2d.nc', crs=3857)
# Print the mesh
print(type(mod.mesh))
mod.mesh

<class 'xugrid.core.wrap.UgridDataset'>

<xarray.Dataset> Size: 351kB
Dimensions:                     (mesh2d_nNodes: 81, mesh2d_nFaces: 64,
                                 mesh2d_nEdges: 144, network1d_nNodes: 1014,
                                 network1d_nEdges: 1007,
                                 network1d_nGeometryNodes: 2290)
Coordinates: (12/13)
    mesh2d_node_x               (mesh2d_nNodes) float64 648B dask.array<chunksize=(81,), meta=np.ndarray>
    mesh2d_node_y               (mesh2d_nNodes) float64 648B dask.array<chunksize=(81,), meta=np.ndarray>
    mesh2d_face_x               (mesh2d_nFaces) float64 512B dask.array<chunksize=(64,), meta=np.ndarray>
    mesh2d_face_y               (mesh2d_nFaces) float64 512B dask.array<chunksize=(64,), meta=np.ndarray>
    mesh2d_edge_x               (mesh2d_nEdges) float64 1kB dask.array<chunksize=(144,), meta=np.ndarray>
    mesh2d_edge_y               (mesh2d_nEdges) float64 1kB dask.array<chunksize=(144,), meta=np.ndarray>
    ...                          ...
    network1d_edge_y            (network1d_nEdges) float64 8kB dask.array<chunksize=(1007,), meta=np.ndarray>
  * mesh2d_nEdges               (mesh2d_nEdges) int64 1kB 0 1 2 ... 141 142 143
  * mesh2d_nNodes               (mesh2d_nNodes) int64 648B 0 1 2 3 ... 78 79 80
  * network1d_nEdges            (network1d_nEdges) int64 8kB 0 1 2 ... 1005 1006
  * mesh2d_nFaces               (mesh2d_nFaces) int64 512B 0 1 2 3 ... 61 62 63
  * network1d_nNodes            (network1d_nNodes) int64 8kB 0 1 2 ... 1012 1013
Dimensions without coordinates: network1d_nGeometryNodes
Data variables:
    network1d_node_x            (network1d_nNodes) float64 8kB dask.array<chunksize=(1014,), meta=np.ndarray>
    network1d_node_y            (network1d_nNodes) float64 8kB dask.array<chunksize=(1014,), meta=np.ndarray>
    network1d_node_id           (network1d_nNodes) |S40 41kB dask.array<chunksize=(1014,), meta=np.ndarray>
    network1d_node_long_name    (network1d_nNodes) |S80 81kB dask.array<chunksize=(1014,), meta=np.ndarray>
    network1d_branch_id         (network1d_nEdges) |S40 40kB dask.array<chunksize=(1007,), meta=np.ndarray>
    network1d_branch_long_name  (network1d_nEdges) |S80 81kB dask.array<chunksize=(1007,), meta=np.ndarray>
    network1d_edge_length       (network1d_nEdges) float64 8kB dask.array<chunksize=(1007,), meta=np.ndarray>
    network1d_branch_order      (network1d_nEdges) int32 4kB dask.array<chunksize=(1007,), meta=np.ndarray>
    network1d_geometry          int32 4B ...
    network1d_geom_node_count   (network1d_nEdges) int32 4kB dask.array<chunksize=(1007,), meta=np.ndarray>
    network1d_geom_x            (network1d_nGeometryNodes) float64 18kB dask.array<chunksize=(2290,), meta=np.ndarray>
    network1d_geom_y            (network1d_nGeometryNodes) float64 18kB dask.array<chunksize=(2290,), meta=np.ndarray>
Attributes:
    Conventions:  CF-1.8 UGRID-1.0

xarray.Dataset

• Dimensions:
  • mesh2d_nNodes: 81
  • mesh2d_nFaces: 64
  • mesh2d_nEdges: 144
  • network1d_nNodes: 1014
  • network1d_nEdges: 1007
  • network1d_nGeometryNodes: 2290
• Coordinates: (13)
  • mesh2d_node_x
    (mesh2d_nNodes)
    float64
    dask.array<chunksize=(81,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    longitude

    Array Chunk Bytes 648 B 648 B Shape (81,) (81,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • mesh2d_node_y
    (mesh2d_nNodes)
    float64
    dask.array<chunksize=(81,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    latitude

    Array Chunk Bytes 648 B 648 B Shape (81,) (81,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • mesh2d_face_x
    (mesh2d_nFaces)
    float64
    dask.array<chunksize=(64,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    longitude

    Array Chunk Bytes 512 B 512 B Shape (64,) (64,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • mesh2d_face_y
    (mesh2d_nFaces)
    float64
    dask.array<chunksize=(64,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    latitude

    Array Chunk Bytes 512 B 512 B Shape (64,) (64,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • mesh2d_edge_x
    (mesh2d_nEdges)
    float64
    dask.array<chunksize=(144,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    longitude

    Array Chunk Bytes 1.12 kiB 1.12 kiB Shape (144,) (144,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • mesh2d_edge_y
    (mesh2d_nEdges)
    float64
    dask.array<chunksize=(144,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    latitude

    Array Chunk Bytes 1.12 kiB 1.12 kiB Shape (144,) (144,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • network1d_edge_x
    (network1d_nEdges)
    float64
    dask.array<chunksize=(1007,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    longitude

    Array Chunk Bytes 7.87 kiB 7.87 kiB Shape (1007,) (1007,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • network1d_edge_y
    (network1d_nEdges)
    float64
    dask.array<chunksize=(1007,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    latitude

    Array Chunk Bytes 7.87 kiB 7.87 kiB Shape (1007,) (1007,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • mesh2d_nEdges
    (mesh2d_nEdges)
    int64
    0 1 2 3 4 5 ... 139 140 141 142 143

    array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,
            14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,
            28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,
            42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,
            56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
            70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
            84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,
            98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
           112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
           126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
           140, 141, 142, 143])

  • mesh2d_nNodes
    (mesh2d_nNodes)
    int64
    0 1 2 3 4 5 6 ... 75 76 77 78 79 80

    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
           18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
           36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
           54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
           72, 73, 74, 75, 76, 77, 78, 79, 80])

  • network1d_nEdges
    (network1d_nEdges)
    int64
    0 1 2 3 4 ... 1003 1004 1005 1006

    array([   0,    1,    2, ..., 1004, 1005, 1006])

  • mesh2d_nFaces
    (mesh2d_nFaces)
    int64
    0 1 2 3 4 5 6 ... 58 59 60 61 62 63

    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
           18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
           36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
           54, 55, 56, 57, 58, 59, 60, 61, 62, 63])

  • network1d_nNodes
    (network1d_nNodes)
    int64
    0 1 2 3 4 ... 1010 1011 1012 1013

    array([   0,    1,    2, ..., 1011, 1012, 1013])

• Data variables: (12)
  • network1d_node_x
    (network1d_nNodes)
    float64
    dask.array<chunksize=(1014,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    projection_x_coordinate

    long_name :

    x coordinates of network nodes

    units :

    m

    Array Chunk Bytes 7.92 kiB 7.92 kiB Shape (1014,) (1014,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • network1d_node_y
    (network1d_nNodes)
    float64
    dask.array<chunksize=(1014,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    projection_y_coordinate

    long_name :

    y coordinates of network nodes

    units :

    m

    Array Chunk Bytes 7.92 kiB 7.92 kiB Shape (1014,) (1014,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • network1d_node_id
    (network1d_nNodes)
    |S40
    dask.array<chunksize=(1014,), meta=np.ndarray>

    long_name :

    ID of network nodes

    Array Chunk Bytes 39.61 kiB 39.61 kiB Shape (1014,) (1014,) Dask graph 1 chunks in 2 graph layers Data type |S40 numpy.ndarray

  • network1d_node_long_name
    (network1d_nNodes)
    |S80
    dask.array<chunksize=(1014,), meta=np.ndarray>

    long_name :

    Long name of network nodes

    Array Chunk Bytes 79.22 kiB 79.22 kiB Shape (1014,) (1014,) Dask graph 1 chunks in 2 graph layers Data type |S80 numpy.ndarray

  • network1d_branch_id
    (network1d_nEdges)
    |S40
    dask.array<chunksize=(1007,), meta=np.ndarray>

    long_name :

    ID of branch geometries

    Array Chunk Bytes 39.34 kiB 39.34 kiB Shape (1007,) (1007,) Dask graph 1 chunks in 2 graph layers Data type |S40 numpy.ndarray

  • network1d_branch_long_name
    (network1d_nEdges)
    |S80
    dask.array<chunksize=(1007,), meta=np.ndarray>

    long_name :

    Long name of branch geometries

    Array Chunk Bytes 78.67 kiB 78.67 kiB Shape (1007,) (1007,) Dask graph 1 chunks in 2 graph layers Data type |S80 numpy.ndarray

  • network1d_edge_length
    (network1d_nEdges)
    float64
    dask.array<chunksize=(1007,), meta=np.ndarray>

    _FillValue :

    nan

    long_name :

    Real length of branch geometries

    units :

    m

    Array Chunk Bytes 7.87 kiB 7.87 kiB Shape (1007,) (1007,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • network1d_branch_order
    (network1d_nEdges)
    int32
    dask.array<chunksize=(1007,), meta=np.ndarray>

    long_name :

    Order of branches for interpolation

    mesh :

    network1d

    location :

    edge

    Array Chunk Bytes 3.93 kiB 3.93 kiB Shape (1007,) (1007,) Dask graph 1 chunks in 2 graph layers Data type int32 numpy.ndarray

  • network1d_geometry
    ()
    int32
    ...

    geometry_type :

    line

    long_name :

    1D Geometry

    node_count :

    network1d_geom_node_count

    node_coordinates :

    network1d_geom_x network1d_geom_y

    [1 values with dtype=int32]

  • network1d_geom_node_count
    (network1d_nEdges)
    int32
    dask.array<chunksize=(1007,), meta=np.ndarray>

    long_name :

    Number of geometry nodes per branch

    Array Chunk Bytes 3.93 kiB 3.93 kiB Shape (1007,) (1007,) Dask graph 1 chunks in 2 graph layers Data type int32 numpy.ndarray

  • network1d_geom_x
    (network1d_nGeometryNodes)
    float64
    dask.array<chunksize=(2290,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    projection_x_coordinate

    long_name :

    x-coordinate of branch geometry nodes

    units :

    m

    Array Chunk Bytes 17.89 kiB 17.89 kiB Shape (2290,) (2290,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

  • network1d_geom_y
    (network1d_nGeometryNodes)
    float64
    dask.array<chunksize=(2290,), meta=np.ndarray>

    _FillValue :

    nan

    standard_name :

    projection_y_coordinate

    long_name :

    y-coordinate of branch geometry nodes

    units :

    m

    Array Chunk Bytes 17.89 kiB 17.89 kiB Shape (2290,) (2290,) Dask graph 1 chunks in 2 graph layers Data type float64 numpy.ndarray

• Indexes: (5)
  • mesh2d_nEdges
    PandasIndex

    PandasIndex(RangeIndex(start=0, stop=144, step=1, name='mesh2d_nEdges'))

  • mesh2d_nNodes
    PandasIndex

    PandasIndex(RangeIndex(start=0, stop=81, step=1, name='mesh2d_nNodes'))

  • network1d_nEdges
    PandasIndex

    PandasIndex(RangeIndex(start=0, stop=1007, step=1, name='network1d_nEdges'))

  • mesh2d_nFaces
    PandasIndex

    PandasIndex(RangeIndex(start=0, stop=64, step=1, name='mesh2d_nFaces'))

  • network1d_nNodes
    PandasIndex

    PandasIndex(RangeIndex(start=0, stop=1014, step=1, name='network1d_nNodes'))

• Attributes: (1)

  Conventions :

  CF-1.8 UGRID-1.0

In HydroMT, you have a couple of properties that allow you to get the names of the different grids in mesh mesh_names, extract a specific grid from the mesh with mesh_datasets or without data mesh_grids or convert the grids to geopandas.GeoDataFrame mesh_gdf.

Let’s check the available grids in our mesh and plot them:

mod.mesh_names

['mesh2d', 'network1d']

# Plot the different mesh grids
fig, ax = plt.subplots(figsize = (5, 6))
# Mesh2d
mod.mesh_grids["mesh2d"].plot(ax=ax, facecolor="none", edgecolor="k", label="mesh2d")
# Mesh1d
mod.mesh_grids["network1d"].plot(ax=ax, label="network1d")

# Plot legends
ax.legend()
ax.set_title("Mesh grids")
ax.set_xlabel("x")
ax.set_ylabel("y")

Text(0, 0.5, 'y')

With HydroMT, you can create a 2D mesh grid using the setup_mesh2d method. This method parses the HydroMT region option to define the geographic region of interest and mesh of the MeshModel to build and once done, adds region into the geoms component and 2D grid into the mesh component. You can check the required arguments in the docs.

With this method, you can generate a 2D regular mesh within a bounding box or geometry, or from reading an existing mesh file. We will see an example for both of them.

# First instantiate a new mesh model
root = "tmp_mesh_model"
mod = hydromt.MeshModel(
    root=root,
    mode="w",
    data_libs=["artifact_data", "data/vito_reclass.yml"],
    logger=logger,
)

2024-02-26 15:13:12,624 - working with mesh models - data_catalog - INFO - Reading data catalog archive artifact_data v0.0.8

2024-02-26 15:13:12,625 - working with mesh models - data_catalog - INFO - Parsing data catalog from /home/runner/.hydromt_data/artifact_data/v0.0.8/data_catalog.yml

2024-02-26 15:13:12,672 - working with mesh models - data_catalog - INFO - Parsing data catalog from data/vito_reclass.yml

2024-02-26 15:13:12,674 - working with mesh models - log - DEBUG - Writing log messages to new file /home/runner/work/hydromt/hydromt/docs/_examples/tmp_mesh_model/hydromt.log.

2024-02-26 15:13:12,675 - working with mesh models - model_api - INFO - Initializing mesh_model model from hydromt (v0.9.4.dev0).

# Generate a 2D mesh from file
region = {'mesh': 'data/mesh_model/mesh1d2d.nc', 'grid_name': 'mesh2d'}
mod._mesh = None # delete the previous mesh
mod.setup_mesh2d(
    region=region,
    crs = 3857,
    grid_name="mesh2d",
)
# Save and reset mesh
mesh1 = mod.mesh_gdf["mesh2d"].copy()
mod._mesh = None

# Generate a 2D mesh from bounding box and resolution
region = {'bbox': [12.09, 46.45, 12.20, 46.50]}
mod.setup_mesh2d(
    region=region,
    res=1000,
    crs=3857,
    grid_name="mesh2d",
)
# Save and reset mesh
mesh2 = mod.mesh_gdf["mesh2d"].copy()

2024-02-26 15:13:12,680 - working with mesh models - model_mesh - INFO - Preparing 2D mesh.

2024-02-26 15:13:12,702 - working with mesh models - basin_mask - DEBUG - Parsed region (kind=mesh): {'grid_name': 'mesh2d', 'mesh': <xarray.Dataset> Size: 351kB
Dimensions:                     (mesh2d_nNodes: 81, mesh2d_nFaces: 64,
                                 mesh2d_nEdges: 144, network1d_nNodes: 1014,
                                 network1d_nEdges: 1007,
                                 network1d_nGeometryNodes: 2290)
Coordinates: (12/14)
    mesh2d_node_x               (mesh2d_nNodes) float64 648B ...
    mesh2d_node_y               (mesh2d_nNodes) float64 648B ...
    mesh2d_face_x               (mesh2d_nFaces) float64 512B ...
    mesh2d_face_y               (mesh2d_nFaces) float64 512B ...
    mesh2d_edge_x               (mesh2d_nEdges) float64 1kB ...
    mesh2d_edge_y               (mesh2d_nEdges) float64 1kB ...
    ...                          ...
    spatial_ref                 int32 4B ...
  * mesh2d_nNodes               (mesh2d_nNodes) int64 648B 0 1 2 3 ... 78 79 80
  * mesh2d_nEdges               (mesh2d_nEdges) int64 1kB 0 1 2 ... 141 142 143
  * network1d_nEdges            (network1d_nEdges) int64 8kB 0 1 2 ... 1005 1006
  * mesh2d_nFaces               (mesh2d_nFaces) int64 512B 0 1 2 3 ... 61 62 63
  * network1d_nNodes            (network1d_nNodes) int64 8kB 0 1 2 ... 1012 1013
Dimensions without coordinates: network1d_nGeometryNodes
Data variables:
    network1d_node_x            (network1d_nNodes) float64 8kB ...
    network1d_node_y            (network1d_nNodes) float64 8kB ...
    network1d_node_id           (network1d_nNodes) |S40 41kB ...
    network1d_node_long_name    (network1d_nNodes) |S80 81kB ...
    network1d_branch_id         (network1d_nEdges) |S40 40kB ...
    network1d_branch_long_name  (network1d_nEdges) |S80 81kB ...
    network1d_edge_length       (network1d_nEdges) float64 8kB ...
    network1d_branch_order      (network1d_nEdges) int32 4kB ...
    network1d_geometry          int32 4B ...
    network1d_geom_node_count   (network1d_nEdges) int32 4kB ...
    network1d_geom_x            (network1d_nGeometryNodes) float64 18kB ...
    network1d_geom_y            (network1d_nGeometryNodes) float64 18kB ...
Attributes:
    Conventions:  CF-1.8 UGRID-1.0}

2024-02-26 15:13:12,709 - working with mesh models - mesh - WARNING - Mesh data from mesh file doesn't have a CRS. Assuming crs option EPSG:3857

2024-02-26 15:13:12,717 - working with mesh models - model_mesh - INFO - Preparing 2D mesh.

2024-02-26 15:13:12,717 - working with mesh models - basin_mask - DEBUG - Parsed region (kind=bbox): {'bbox': [12.09, 46.45, 12.2, 46.5]}

# Plot
fig = plt.figure(figsize=(10, 4))
ax = plt.subplot()
# plot mesh1 mesh2 gdf without facecolor
mesh1.plot(ax=ax, facecolor="none", edgecolor="k", label="mesh from bbox")
mesh2.plot(ax=ax, facecolor="pink", edgecolor="r", label="mesh from file")

<Axes: >

Add data to 2D mesh

To prepare and resample data to a 2D grid in mesh, the core for now has two methods available: setup_mesh2d_from_rasterdataset and setup_mesh2d_from_raster_reclass.

But back to our example, let’s add both a DEM map from the data source merit_hydro_1k and a landuse and manning roughness map based on reclassified landuse data from the vito dataset to the mesh2d grid of our model mesh object.

For this we will use xugrid Regridder methods to interpolate raster data to our mesh. Our current model resolution is 500*500 meters so for the different data source we will resample using the methods:

• merit_hydro_1k: centroid as the resolution of the data is 1000*1000 meters. You could also choose mean or geometric_mean or others if you wish.

• landuse: mode (most representative) as we want to conserve the land use classification values.

• manning: the resolution of vito is 250250 meters so we can choose to use for example the mean* method.

mod.setup_mesh2d_from_rasterdataset(
    raster_fn="merit_hydro_1k",
    grid_name="mesh2d",
    variables="elevtn",
    fill_method=None,
    resampling_method="centroid",
    rename={"elevtn": "DEM"},
)
mod.setup_mesh2d_from_raster_reclass(
    raster_fn="vito",
    grid_name="mesh2d",
    fill_method="nearest",
    reclass_table_fn="vito_reclass",  # Note: from local data catalog
    reclass_variables=["landuse", "manning"],
    resampling_method=["mode", "mean"],
)

2024-02-26 15:13:12,876 - working with mesh models - model_mesh - INFO - Preparing mesh data from raster source merit_hydro_1k

2024-02-26 15:13:12,884 - working with mesh models - rasterdataset - INFO - Reading merit_hydro_1k raster data from /home/runner/.hydromt_data/artifact_data/v0.0.8/merit_hydro_1k/{variable}.tif

2024-02-26 15:13:12,900 - working with mesh models - rasterdataset - DEBUG - Clip to [12.091, 46.452, 12.199, 46.501] (epsg:4326))

2024-02-26 15:13:12,907 - working with mesh models - mesh - INFO - Preparing regridder for centroid method

2024-02-26 15:13:12,928 - working with mesh models - mesh - INFO - Resampling elevtn to mesh2d using centroid method

2024-02-26 15:13:12,941 - working with mesh models - model_mesh - INFO - Preparing mesh data by reclassifying the data in vito based on vito_reclass.

2024-02-26 15:13:12,945 - working with mesh models - rasterdataset - INFO - Reading vito raster data from /home/runner/.hydromt_data/artifact_data/v0.0.8/vito.tif

2024-02-26 15:13:12,959 - working with mesh models - rasterdataset - DEBUG - Clip to [12.091, 46.452, 12.199, 46.501] (epsg:4326))

2024-02-26 15:13:12,961 - working with mesh models - dataframe - INFO - Reading vito_reclass csv data from /home/runner/work/hydromt/hydromt/docs/_examples/data/vito_reclass.csv

2024-02-26 15:13:12,992 - working with mesh models - mesh - INFO - Preparing regridder for mean method

2024-02-26 15:13:13,024 - working with mesh models - mesh - INFO - Preparing regridder for mode method

2024-02-26 15:13:13,027 - working with mesh models - mesh - INFO - Resampling landuse to mesh2d using mode method

2024-02-26 15:13:14,334 - working with mesh models - mesh - INFO - Resampling manning to mesh2d using mean method

['landuse', 'manning']

# Plot
fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(15, 4), sharey=True)
mod.mesh["DEM"].ugrid.plot(ax=axes[0], cmap="terrain")
axes[0].set_title("Elevation")

mod.mesh["landuse"].ugrid.plot(ax=axes[1], cmap="Pastel1")
axes[1].set_title("Landuse")

mod.mesh["manning"].ugrid.plot(ax=axes[2], cmap="viridis")
axes[2].set_title("Manning roughness")

Text(0.5, 1.0, 'Manning roughness')