Skip to content

models.snow

Snow model registry.

This module provides access to snow models implemented in the holmes_rs Rust extension.

get_model 

get_model(
    model: SnowModel,
) -> Callable[
    [
        NDArray[float64],
        NDArray[float64],
        NDArray[float64],
        NDArray[uintp],
        NDArray[float64],
        float,
    ],
    NDArray[float64],
]

Get a wrapped snow model simulation function.

The returned function wraps the underlying Rust implementation with error handling and logging.

Parameters:

Name Type Description Default
model SnowModel

Model name (see SnowModel for valid options)

 required

Returns:

Type Description
Callable

Simulation function that takes precipitation, temperature, params, day_of_year, altitude_layers, and median_altitude, and returns adjusted precipitation
Source code in src/holmes/models/snow.py 
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
def get_model(
    model: SnowModel,
) -> Callable[
    [
        npt.NDArray[np.float64],  # params
        npt.NDArray[np.float64],  # precipitation
        npt.NDArray[np.float64],  # temperature
        npt.NDArray[np.uintp],  # day_of_year
        npt.NDArray[np.float64],  # altitude_layers
        float,  # median_altitude
    ],
    npt.NDArray[np.float64],
]:
    """
    Get a wrapped snow model simulation function.

    The returned function wraps the underlying Rust implementation
    with error handling and logging.

    Parameters
    ----------
    model : SnowModel
        Model name (see SnowModel for valid options)

    Returns
    -------
    Callable
        Simulation function that takes precipitation, temperature, params,
        day_of_year, altitude_layers, and median_altitude,
        and returns adjusted precipitation
    """
    match model:
        case "cemaneige":
            simulate_fn = cemaneige.simulate
        case _:  # pragma: no cover
            assert_never(model)

    def wrapped_simulate(
        params: npt.NDArray[np.float64],
        precipitation: npt.NDArray[np.float64],
        temperature: npt.NDArray[np.float64],
        day_of_year: npt.NDArray[np.uintp],
        altitude_layers: npt.NDArray[np.float64],
        median_altitude: float,
    ) -> npt.NDArray[np.float64]:
        """Wrapped snow simulation function with error handling."""
        try:
            return simulate_fn(
                params,
                precipitation,
                temperature,
                day_of_year,
                altitude_layers,
                median_altitude,
            )
        except (HolmesNumericalError, HolmesValidationError) as exc:
            logger.error(f"Snow simulation failed for {model}: {exc}")
            raise
        except Exception as exc:  # pragma: no cover
            logger.exception(f"Unexpected error in {model} snow simulation")
            raise HolmesError(f"Snow simulation failed: {exc}") from exc

    return wrapped_simulate