smashbox 1.0__py2.py3-none-any.whl

smashbox/tools/tools.py

@@ -0,0 +1,461 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jul 15 16:40:32 2025
+
+@author: maxime
+"""
+
+import os
+import glob
+import numpy as np
+import pandas as pd
+import numbers
+from tqdm import tqdm
+
+from rich import print
+from rich.tree import Tree
+import inspect
+
+from typing import get_args
+
+
+class Dict2Struct:
+    def __init__(self, **entries):
+        self.__dict__.update(entries)
+
+
+def with_reticulate():
+    # Exemple : RETICULATE_PYTHON env variable peut être définie
+    return "R_SESSION_INITIALIZED" in os.environ or "RETICULATE_PYTHON" in os.environ
+
+
+def build_object_tree(obj, name="root"):
+
+    tree = Tree(f"[bold cyan]Object {name}[/] ({type(obj).__name__})")
+
+    for attr in dir(obj):
+
+        if attr.startswith("_") or attr.startswith("__") and attr.endswith("__"):
+            continue
+        try:
+            val = getattr(obj, attr)
+
+        except Exception:
+            continue
+
+        if inspect.ismethod(val) or inspect.isfunction(val):
+            tree.add(f"[green]Method:[/] {attr}()")
+
+        elif inspect.isclass(val):
+            tree.add(f"[blue]Class:[/] {attr}")
+            subtree = build_object_tree(val, name=attr)
+
+        elif isinstance(val, dict):
+            tree.add(f"[red]Attribut:[/]  {attr} = {val.keys()}")
+        elif isinstance(
+            val,
+            (
+                int,
+                float,
+                str,
+                bool,
+                type(None),
+                list,
+                set,
+                tuple,
+            ),
+        ):
+            tree.add(f"[red]Attribute:[/] {attr} = {repr(val)}")
+        elif isinstance(val, (pd.DataFrame, np.ndarray)):
+            tree.add(f"[red]Attribute:[/] {attr} = {type(val)}")
+        elif "<class 'smashbox" in str(type(val)):
+            subtree = build_object_tree(val, name=attr)
+            tree.add(subtree)
+        else:
+            tree.add(f"[red]Unknown attribute type:[/] {attr} = {type(val)}")
+
+    return tree
+
+
+def autocast_args(func):
+    """
+    Decrorator function. Usgae @autocast_args previous the function definition
+    The goal of this decorator is to test input args type and auto cast them if possible.
+    If the type of the arg is not good and cannot be auto-casted, the function will throw
+    an execption.
+    :param func: Function on which to apply the decorator
+    :type func: Any function
+    """
+
+    sig = inspect.signature(func)
+    annotations = func.__annotations__
+
+    def wrapper(*args, **kwargs):
+
+        bound = sig.bind(*args, **kwargs)
+        bound.apply_defaults()
+
+        for name, value in bound.arguments.items():
+            if name in annotations:
+
+                target_type = annotations[name]
+
+                args_ = get_args(target_type)
+
+                if target_type is None and len(args_) == 0:
+                    args_ = (type(None),)
+                    target_type = type(None)
+
+                if not type(value) in args_:
+
+                    if len(args_) > 1 and type(None) in args_:
+
+                        converted = False
+                        for t in args_:
+
+                            if t is not type(None):
+
+                                if value is not None:
+                                    try:
+                                        print(
+                                            f"</> Warning: Arg '{name}' of type {type(value)} is being"
+                                            f" converted to {t}"
+                                        )
+                                        bound.arguments[name] = t(value)
+                                        converted = True
+                                    except:
+                                        pass
+
+                                if converted:
+                                    break
+
+                        if not converted:
+                            raise TypeError(
+                                f"</> Error: Arg '{name}' must be a type of "
+                                f" {args_}, got {value}"
+                                f" ({type(value).__name__})"
+                            )
+
+                    else:
+                        if not isinstance(value, target_type):
+                            try:
+                                print(
+                                    f"</> Warning: Arg '{name}' of type {type(value)} is being"
+                                    f" converted to {target_type}"
+                                )
+                                bound.arguments[name] = target_type(value)
+                            except Exception:
+                                raise TypeError(
+                                    f"</> Error: Arg '{name}' must be a type of "
+                                    f" {target_type.__name__}, got {value}"
+                                    f" ({type(value).__name__})"
+                                )
+
+        return func(*bound.args, **bound.kwargs)
+
+    return wrapper
+
+
+def infograffas_bbox_extractor(info_graffas):
+    """
+    A function to extract the bbox from info_graffas object and adapt it to the Smash
+    convention
+
+    Parameter:
+    ----------
+    info_graffas: Dictionary containing information about the Graffas domain. At least: a dictionary `domain` containing keys 'left,bottom,right,top' associated to each
+     bouning coordinates and a key 'resolution_sim' containing a real with the resolution of the domain in meter.
+
+     Return
+     ------
+
+     bbox, a dictionary of the bbox adapted to Smash.
+    """
+
+    bbox = {
+        "left": info_graffas["domain"]["left"] - info_graffas["resolution_sim"] / 2,
+        "bottom": info_graffas["domain"]["bottom"] - info_graffas["resolution_sim"] / 2,
+        "right": info_graffas["domain"]["right"] + info_graffas["resolution_sim"] / 2,
+        "top": info_graffas["domain"]["top"] + info_graffas["resolution_sim"] / 2,
+    }
+
+    return bbox
+
+
+def GraffasVector2SmashArray(vdata, coordinates, resolution):
+
+    coord_x = ((coordinates["X"] - min(coordinates["X"])) / resolution).astype(int)
+    coord_y = ((coordinates["Y"] - min(coordinates["Y"])) / resolution).astype(int)
+
+    graffas_prcp = np.zeros(shape=(max(coord_x) + 1, max(coord_y) + 1, vdata.shape[1]))
+
+    for t in tqdm(range(graffas_prcp.shape[2])):
+        for j in range(len(coord_x)):
+            c_x = coord_x[j]
+            c_y = coord_y[j]
+            graffas_prcp[c_x, c_y, t] = vdata[j, t]
+
+    return graffas_prcp
+
+
+def array_isin(arr1: np.ndarray = None, arr2: np.ndarray = None):
+
+    pos = []
+
+    for i in range(len(arr2)):
+
+        if not np.any(np.isin(arr1, arr2[i]) == 1):
+            print(f"</> Outlet name `{arr2[i]}` does not exist in the mesh.")
+
+    if arr1 is not None and arr2 is not None:
+        pos = list(np.where(np.isin(arr1, arr2))[0])
+
+    if len(pos) == 0:
+        raise ValueError("Invalid outlets name.")
+
+    return pos
+
+
+def check_asset_path(asset_dir: str = "", path: None | os.PathLike = None):
+
+    if path is None:
+        return path
+
+    if not os.path.exists(path):
+
+        mypath = os.path.join(asset_dir)
+        matched_file = sorted(glob.glob(f"{mypath}/*{path}*"))
+
+        if len(matched_file) == 0:
+            raise ValueError(
+                f"'{path}' is not a valid {asset_dir} filename."
+                "Choice are: {os.listdir(mypath)}"
+            )
+        else:
+            path = matched_file[0]
+
+    return path
+
+
+def print_tree(root_path, prefix=""):
+
+    files = sorted(os.listdir(root_path))
+
+    for index, name in enumerate(files):
+
+        path = os.path.join(root_path, name)
+        connector = "└── " if index == len(files) - 1 else "├── "
+
+        print(prefix + connector + name)
+
+        if os.path.isdir(path):
+            extension = "    " if index == len(files) - 1 else "│   "
+            print_tree(path, prefix + extension)
+
+
+@autocast_args
+def time_resample_prcp_array(
+    array: np.ndarray | None,
+    input_dt: int | float = 3600.0,
+    output_dt: float = 3600.0,
+    t_axis: int = 2,
+):
+    """
+    Resample an array of prcp for a given time-step.
+    :param array: the matrix containing the discharge with shape (nbx, nby, nbts)
+    :type array: np.ndarray | None
+    :param quantile_duration: The duration of the quantile (hours), defaults to 1
+    :type quantile_duration: int | float, optional
+    :param model_time_step: the time-step of the Smash model (seconds), defaults to 3600
+    :type model_time_step: float, optional
+    :param t_axis: The array axis direction of the time-step, defaults to 2
+    :type t_axis: int, optional
+    :return: The resampled array
+    :rtype: np.ndarray
+
+    """
+
+    # resample array to the new duration
+    if pd.Timedelta(seconds=input_dt) < pd.Timedelta(seconds=output_dt):
+
+        if not (output_dt % input_dt == 0):
+            raise ValueError("output_dt must be a factor of intput_dt.")
+
+        print(
+            f"</> Resampling array with time-step `{input_dt}s`"
+            f" to time-step `{output_dt}s`"
+        )
+        chunk_size = int(output_dt / input_dt)
+
+        array_trans = np.moveaxis(array, t_axis, 0)  # Axe à la position 0
+
+        new_shape = (array_trans.shape[0] // chunk_size, chunk_size) + array_trans.shape[
+            1:
+        ]
+
+        array_trans_reshaped = array_trans[
+            0 : chunk_size * (array_trans.shape[0] // chunk_size)
+        ].reshape(new_shape)
+
+        del array_trans
+
+        array_trans_reshaped_sum = np.sum(array_trans_reshaped, axis=1)
+
+        del array_trans_reshaped
+
+        array = np.moveaxis(array_trans_reshaped_sum, 0, t_axis)
+
+        del array_trans_reshaped_mean
+
+    if pd.Timedelta(seconds=input_dt) > pd.Timedelta(seconds=output_dt):
+
+        if not (input_dt % output_dt == 0):
+            raise ValueError("output_dt must be a factor of intput_dt.")
+
+        # array = np.zeros(shape=(2, 2, 6)) + np.random.randint(10, size=(2, 2, 6))
+
+        array = np.moveaxis(
+            array,
+            t_axis,
+            len(array.shape) - 1,
+        )
+
+        chunk_size = int(input_dt / output_dt)
+        # nb_chunk = int(array.shape[len(array.shape) - 1] / chunk_size)
+
+        array = np.repeat(array, chunk_size, axis=2) / chunk_size
+
+        # array = array.reshape(array.shape[0], array.shape[1], nb_chunk, chunk_size).sum(
+        #     -1
+        # )
+
+        array = np.moveaxis(array, len(array.shape) - 1, t_axis)
+
+    return array
+
+
+@autocast_args
+def read_hourly_qobs(qobs_directory, code):
+    start_time = pd.Timestamp("1900-01-01 00:00")
+    end_time = pd.Timestamp.today().round(freq="24h")
+    dt = 3600.0
+
+    npdt = int((end_time - start_time).total_seconds() / dt) + 1
+
+    qobs = np.zeros(shape=(len(code), npdt)) - 99.0
+
+    miss = []
+
+    for i, c in enumerate(code):
+        f = glob.glob(f"{qobs_directory}/**/*{c}*.csv", recursive=True)
+
+        if f:
+            dat = pd.read_csv(f[0])
+            try:
+                file_start_time = pd.Timestamp(dat.columns[0])
+            except Exception:
+                raise ValueError(
+                    f"Column header '{dat.columns[0]}' in the observed discharge file for catchment '{c}' "
+                    f"is not a valid date"
+                ) from None
+
+            file_end_time = file_start_time + pd.Timedelta(seconds=dt * (len(dat) - 1))
+            start_diff = int((start_time - file_start_time).total_seconds() / dt) + 1
+            end_diff = int((end_time - file_start_time).total_seconds() / dt) + 1
+
+            # % Check if observed discharge file contains data for corresponding simulation period
+            if start_diff > dat.index.max() or end_diff < 0:
+                print(
+                    f"</> The provided observed discharge file for catchment '{c}' does not contain data for the "
+                    f"selected simulation period ['{start_time}', '{end_time}']. The file covers the period "
+                    f"['{file_start_time}', '{file_end_time}']",
+                )
+            else:
+                ind_start_dat = max(0, start_diff)
+                ind_end_dat = min(dat.index.max(), end_diff)
+                ind_start_arr = max(0, -start_diff)
+                ind_end_arr = ind_start_arr + ind_end_dat - ind_start_dat
+
+                qobs[i, ind_start_arr:ind_end_arr] = dat.iloc[
+                    ind_start_dat:ind_end_dat, 0
+                ]
+        else:
+            miss.append(c)
+
+    if miss:
+        print(f"</> Missing {len(miss)} observed discharge file(s): {miss}")
+
+    return qobs
+
+
+@autocast_args
+def read_object_as_dict(instance, recursion_counter: int = 0):
+    """
+
+    create a dictionary from a custom python object
+
+    Parameters
+    ----------
+
+    instance : object
+        an custom python object
+
+    Return
+    ------
+
+    key_data: dict
+        an dictionary containing all keys and atributes of the object
+
+    """
+    key_data = {}
+    # key_list = list()
+    # return_list = False
+    recursion_counter = 0
+    for attr in dir(instance):
+        # print(attr)
+        if not attr.startswith("_") and not attr in ["from_handle", "copy"]:
+            try:
+                value = getattr(instance, attr)
+
+                if isinstance(value, (np.ndarray, list, tuple)):
+
+                    if isinstance(value, list):
+                        value = np.array(value).astype("U")
+
+                    if value.dtype == "object" or value.dtype.char == "U":
+                        value = value.astype("U")
+
+                    key_data.update({attr: value})
+
+                elif isinstance(value, dict):
+                    key_data.update({attr: value})
+
+                elif isinstance(value, numbers.Number):
+                    key_data.update({attr: value})
+
+                elif isinstance(value, str):
+                    key_data.update({attr: value})
+
+                elif type(value) == "method":
+                    next(attr)
+
+                else:
+
+                    depp_key_data = read_object_as_dict(
+                        value, recursion_counter=recursion_counter
+                    )
+
+                    recursion_counter = recursion_counter + 1
+
+                    if len(depp_key_data) > 0:
+                        key_data.update({attr: depp_key_data})
+
+                    if recursion_counter > 100:
+                        print("recursion counter exceed the limit of 100... return")
+                        return
+            except:
+                print(f"unknown type for attribute : {attr}")
+                pass
+
+    return key_data

smashbox/tutorial_R.r

@@ -0,0 +1,182 @@
+#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")
+
+bbox=list('left'= 875000.0,
+          'bottom'= 6228000.0,
+          'right'= 1001000.0,
+          'top'= 6320000.0)
+
+#Main initialisation of the module
+sb <- smashbox$SmashBox()
+sb$myparam$set_param("bbox", bbox)
+sb$myparam$set_param("outlets_database", "db_sites")
+
+sb$newmodel("rex")
+
+sb$rex$mysetup$update_setup(
+  list(
+    "start_time"= "2014-01-01 00:00",
+    "end_time"= "2014-02-01 00:00"
+  )
+)
+
+sb$rex$mysetup$update_setup(
+  list(
+    "pet_directory"= "/home/maxime/DATA/ETP-SFR-FRA-INTERA_L93",
+    "prcp_directory"= "/home/maxime/DATA/PLUIE",
+    "qobs_directory"= "/home/maxime/DATA/QOBS_SITE_60M",
+    "start_time"= "2014-01-01 00:00",
+    "end_time"= "2014-02-01 00:00"
+  )
+)
+
+sb$rex$generate_mesh(query="(SURF>40) & (INFLUENCE=='Influence nulle ou faible')", area_error_th=0.2)
+
+sb$rex$myplot$plot_mesh(fig_settings=list("figname"= "output/mesh.png"))
+sb$rex$myplot$plot_catchment_surface_error(fig_settings=list("figname"= "output/mesh_surface_error.png"))
+sb$rex$myplot$plot_catchment_surface_consistency(
+  fig_settings=list("figname"= "output/mesh_surface_consistency.png")
+)
+
+sb$rex$forward_run(return_options=list("q_domain"= TRUE), warmup=100)
+
+
+sb$rex$mystats$foutlets_stats()
+sb$rex$mystats$fspatial_stats()
+sb$rex$mystats$fmisfit_stats()
+
+
+sb$rex$myplot$multiplot_parameters(
+  fig_settings=list("figname"= "output/muliplot_parameters.png", "xsize"=15,"ysize"=15)
+)
+sb$rex$myplot$plot_parameters(fig_settings=list("figname"= "output/cp_parameters.png"))
+
+sb$rex$myplot$plot_outlet_stats(
+  fig_settings=list("figname"= "output/outlets_max_discharges.png")
+)
+sb$rex$myplot$plot_spatial_stats(
+  fig_settings=list("figname"= "output/spatial_max_discharges.png")
+)
+
+
+sb$rex$myplot$plot_hydrograph(fig_settings=list("figname"= "output/discharges_hydrogram.png"))
+
+
+sb$rex$myplot$multiplot_misfit(
+  fig_settings=list("figname"= "output/multiplot_nse_misfit.png", "xsize"= 15, "ysize"= 15)
+)
+sb$rex$myplot$plot_misfit(
+  misfit="nnse", fig_settings=list("figname"= "output/nnse_misfit.png")
+)
+sb$rex$myplot$plot_misfit_map(fig_settings=list("figname"= "output/map_nse_misfit.png"))
+
+
+
+
+#Graffas Tutorial
+
+library(reticulate)
+use_virtualenv("/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/smashbox_env_21/") #use a specific python environnement
+
+#import the package smashbox (must be installed in the python environnement)
+smashbox <- import("smashbox")
+
+path_to_graffas_rainfall="/nas/RHAX/UTILISATEURS/kevin.tartour/2025_Graffas/SPATIAL/Gapeau/DataOutput/simul/RRsim_Gapeau_res_1000_twin1.Rdata"
+GraffasRainfall=load(path_to_graffas_rainfall)
+
+#tranformation des pluies
+
+#méthode 1
+rsb=1000.
+coord_x=(XYsim$X-min(XYsim$X))/1000 +1#col
+coord_y=(XYsim$Y-min(XYsim$Y))/1000 +1#row
+
+#~ thisarray=c(1:max(coord_x)*max(coord_y)*dim(RRsim)[2])
+thisarray=rep(NaN,max(coord_x)*max(coord_y)*dim(RRsim)[2])
+graffas_prcp=array(data=thisarray, dim=c(max(coord_x),max(coord_y),dim(RRsim)[2]))
+
+for (t in 1:dim(RRsim)[2]) {
+    for (j in 1:length(XYsim$X)) {
+            c_x=coord_x[j]
+            c_y=coord_y[j]
+            graffas_prcp[c_x,c_y,t]=RRsim[j,t]
+        }
+    }
+
+
+#deuxième méthode:
+nx <- length(unique(XYsim$X))
+ny <- length(unique(XYsim$Y))
+nt <- ncol(RRsim)
+
+xi <- match(XYsim$X, sort(unique(XYsim$X)))
+yi <- match(XYsim$Y, sort(unique(XYsim$Y)))
+
+# Création du tableau 3D vide
+RRsim_3D <- array(NA, dim = c(nx, ny, nt))
+
+# Répéter les positions (xi, yi) pour chaque pas de temps
+xi_rep <- rep(xi, times = nt)
+yi_rep <- rep(yi, times = nt)
+ti_rep <- rep(1:nt, each = length(xi))
+
+# Remplissage vectorisé
+RRsim_3D[cbind(xi_rep, yi_rep, ti_rep)] <- as.vector(RRsim)
+
+
+
+
+bbox=list('left'= min(XYsim$X),
+          'bottom'= min(XYsim$Y),
+          'right'= min(XYsim$X)+res*dim(graffas_prcp)[1],
+          'top'= min(XYsim$Y)+res*dim(graffas_prcp)[2])
+
+#Main initialisation of the module
+sb <- smashbox$SmashBox()
+sb$myparam$set_param("bbox", bbox)
+sb$myparam$set_param("outlets_database", "db_sites")
+sb$myparam$set_param(
+  "outlets_database_fields",
+  list(
+    "coord_x"= "X_L93",
+    "coord_y"= "Y_L93",
+    "area"= "SURF",
+    "id"= "CODE_SITE"
+  )
+)
+sb$myparam$set_param(
+    "outlets_shapefile",
+    "/nas/RHAX/DONNEES/SIG/BASSINS/CONTOUR/SITES_L93/Hydro_Bassins.shp",
+)
+
+sb$newmodel("gapeau")
+
+sb$gapeau$generate_mesh()
+
+sb$gapeau$myplot$plot_mesh(fig_settings=list("figname"="nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/gapeau_mesh.png"))
+
+sb$gapeau$atmos_data_connector(input_prcp=graffas_prcp[,,(1:365*24*5)])
+
+sb$gapeau$atmos_data_connector(input_prcp=RRsim_3D[,,(1:365*24*5)])
+
+sb$gapeau$model()
+
+sb$gapeau$myplot$multiplot_parameters(
+  fig_settings=list("figname"= "/nas/RHAX/UTILISATEURS/maxime.jay-allemand/smashbox/output/gapeau_parameters.png")
+)
+
+sb$gapeau$forward_run(warmup=365,return_options=list("q_domain"= TRUE))
+
+sb$gapeau$mystats$foutlets_stats()
+sb$gapeau$mystats$fspatial_stats()
+
+sb$gapeau$mystats$fquantile_stats(
+        chunk_size=2, estimate_method="MLE", ncpu=as.integer(6), fit="gumbel"
+    )
+
+