From 17b02f22a4ac049719542a8fcee2fa36bde10782 Mon Sep 17 00:00:00 2001 From: Daafip Date: Tue, 5 Mar 2024 14:35:03 +0100 Subject: [PATCH 1/2] Add Sonarcloud badge,fix inplace=True bad practice --- README.md | 1 + src/ewatercycle_HBV/forcing.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 6b3f0cf..bef92f5 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,7 @@ [![PyPI](https://img.shields.io/pypi/v/ewatercycle-HBV)](https://pypi.org/project/ewatercycle-HBV/) [![github license badge](https://img.shields.io/github/license/Daafip/ewatercycle-hbv)](https://github.com/Daafip/ewatercycle-hbv) [![fair-software badge](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8B%20%20%E2%97%8B%20%20%E2%97%8B-yellow)](https://fair-software.eu) +[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Daafip_ewatercycle-hbv&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Daafip_ewatercycle-hbv) This package is based on the [Leaky bucket](https://github.com/eWaterCycle/ewatercycle-leakybucket/tree/main) & is a wrapper for the [HBV-bmi](https://github.com/Daafip/HBV-bmi) model. diff --git a/src/ewatercycle_HBV/forcing.py b/src/ewatercycle_HBV/forcing.py index c3f5c29..ebb8f8e 100644 --- a/src/ewatercycle_HBV/forcing.py +++ b/src/ewatercycle_HBV/forcing.py @@ -97,7 +97,7 @@ def from_test_txt(self) -> xr.Dataset: names = ["year", "month", "day", "pr","Q", "pev"] df_in = pd.DataFrame(forcing, columns=names) df_in.index = df_in.apply(lambda x: pd.Timestamp(f'{int(x.year)}-{int(x.month)}-{int(x.day)}'), axis=1) - df_in.drop(columns=["year", "month", "day"], inplace=True) + df_in = df_in.drop(columns=["year", "month", "day"]) df_in.index.name = "time" # TODO use netcdf-cf conventions ds = xr.Dataset(data_vars=df_in, From cfc1b457ca7136df663925f304d5c456ad211be4 Mon Sep 17 00:00:00 2001 From: Daafip Date: Thu, 7 Mar 2024 10:48:28 +0100 Subject: [PATCH 2/2] adding docs --- docs/Makefile | 20 + docs/make.bat | 35 ++ docs/source/_static/README.rst | 61 +++ docs/source/conf.py | 38 ++ docs/source/example_model_run_HBV.ipynb | 539 ++++++++++++++++++++++++ docs/source/index.rst | 69 +++ 6 files changed, 762 insertions(+) create mode 100644 docs/Makefile create mode 100644 docs/make.bat create mode 100644 docs/source/_static/README.rst create mode 100644 docs/source/conf.py create mode 100644 docs/source/example_model_run_HBV.ipynb create mode 100644 docs/source/index.rst diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..d0c3cbf --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..747ffb7 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/source/_static/README.rst b/docs/source/_static/README.rst new file mode 100644 index 0000000..58d0f10 --- /dev/null +++ b/docs/source/_static/README.rst @@ -0,0 +1,61 @@ +eWaterCycle plugin - HBV +======================== + +|PyPI| |github license badge| |fair-software badge| |Quality Gate +Status| + +This package is based on the `Leaky +bucket `__ +& is a wrapper for the `HBV-bmi `__ +model. + +HBV (Hydrologiska Byråns Vattenbalansavdelning) is a conceptual +hydrological model. For more information on it’s history, see this +`paper `__. + +This current implementation is *without* a snow reservoir. + +Installation +------------ + +Install this package alongside your eWaterCycle installation + +.. code:: console + + pip install ewatercycle-hbv + +Then HBV becomes available as one of the eWaterCycle models + +.. code:: python + + from ewatercycle.models import HBV + +Implementing your own model +--------------------------- + +For more information on how this plugin works, and on how to implement +your own model see the `plugin +guide `__ + +Changelog +--------- + +Changes can be found in +`CHANGELOG.md `__ +on GitHub + +License +------- + +This is a ``ewatercycle-plugin`` & thus this is distributed under the +same terms as the template: the +`Apache-2.0 `__ license. + +.. |PyPI| image:: https://img.shields.io/pypi/v/ewatercycle-HBV + :target: https://pypi.org/project/ewatercycle-HBV/ +.. |github license badge| image:: https://img.shields.io/github/license/Daafip/ewatercycle-hbv + :target: https://github.com/Daafip/ewatercycle-hbv +.. |fair-software badge| image:: https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8B%20%20%E2%97%8B%20%20%E2%97%8B-yellow + :target: https://fair-software.eu +.. |Quality Gate Status| image:: https://sonarcloud.io/api/project_badges/measure?project=Daafip_ewatercycle-hbv&metric=alert_status + :target: https://sonarcloud.io/summary/new_code?id=Daafip_ewatercycle-hbv diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000..228f3cf --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,38 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = 'eWaterCycle-HBV' +copyright = '2024, David Haasnoot' +author = 'David Haasnoot' +release = '\x1b[A\x1b[F\x1b[B\x1b[B\x1b[F\x1b[B\x1b[B' + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + 'sphinx.ext.autodoc', + "nbsphinx", + ] + +templates_path = ['_templates'] +exclude_patterns = [] + +source_suffix = [".rst"] + + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = 'alabaster' +html_static_path = ['_static'] + + +# -- Use autoapi.extension to run sphinx-apidoc ------- +autoapi_dirs = ["../../src"] +autoapi_python_class_content = "both" +autoapi_options = ["members", "undoc-members", "imported-members", "show-inheritance"] \ No newline at end of file diff --git a/docs/source/example_model_run_HBV.ipynb b/docs/source/example_model_run_HBV.ipynb new file mode 100644 index 0000000..c6ccc83 --- /dev/null +++ b/docs/source/example_model_run_HBV.ipynb @@ -0,0 +1,539 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e9cd8d85-eb4a-45d6-925a-e3e770592043", + "metadata": {}, + "source": [ + "### Import modules and verify they work? " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ec7e710a-5aa4-40f9-a1cb-151e3cddbe04", + "metadata": {}, + "outputs": [], + "source": [ + "# general python\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "import numpy as np\n", + "import os\n", + "from pathlib import Path\n", + "import yaml\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4569a0f2-4bea-48cc-b5a4-ca5384e368c6", + "metadata": {}, + "outputs": [], + "source": [ + "# general eWC\n", + "import ewatercycle\n", + "import ewatercycle.models" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "98a3463b-eedd-4f59-a542-6afd58cf6eb4", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# pip install ewatercycle-HBV==1.3.10" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c43ba815-aec1-4123-87ff-5043e75a9ba7", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# pip install HBV==1.0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ea9c713f-e179-4dc7-ba20-843b83de4518", + "metadata": {}, + "outputs": [], + "source": [ + "# for local mode\n", + "from typing import Type\n", + "from ewatercycle.base.model import LocalModel\n", + "from ewatercycle_HBV.model import HBVMethods # Use custom forcing instead\n", + "from HBV import HBV as HBV_bmi\n", + "from bmipy import Bmi\n", + "\n", + "class LocalModelHBV(LocalModel, HBVMethods):\n", + " \"\"\"The HBV eWaterCycle model, with the local BMI.\"\"\"\n", + " bmi_class: Type[Bmi] = HBV_bmi" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6585261f-a0e0-4bfc-bfce-e26acea0e3b0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "__main__.LocalModelHBV" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "LocalModelHBV" + ] + }, + { + "cell_type": "markdown", + "id": "111bc65b-8299-43ba-95fd-e92df6b92707", + "metadata": {}, + "source": [ + "#### set up paths" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "df66893d-b667-4fcc-a841-683f32ed2cc7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PosixPath('/home/davidhaasnoot/eWaterCycle-WSL-WIP/Forcing')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "path = Path.cwd()\n", + "forcing_path = path / \"Forcing\"\n", + "forcing_path" + ] + }, + { + "cell_type": "markdown", + "id": "4787c692-3f9c-402b-9b48-93daeeb47926", + "metadata": {}, + "source": [ + "#### add parameter info" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "33fbba0f-dbc0-4812-9125-79e0df831e7b", + "metadata": {}, + "outputs": [], + "source": [ + "## Array of initial storage terms - we keep these constant for now \n", + "## Si, Su, Sf, Ss\n", + "s_0 = np.array([0, 100, 0, 5])\n", + "\n", + "## Array of parameters min/max bounds as a reference\n", + "## Imax, Ce, Sumax, beta, Pmax, T_lag, Kf, Ks\n", + "p_min_initial= np.array([0, 0.2, 40, .5, .001, 1, .01, .0001])\n", + "p_max_initial = np.array([8, 1, 800, 4, .3, 10, .1, .01])\n", + "p_names = [\"$I_{max}$\", \"$C_e$\", \"$Su_{max}$\", \"β\", \"$P_{max}$\", \"$T_{lag}$\", \"$K_f$\", \"$K_s$\"]\n", + "S_names = [\"Interception storage\", \"Unsaturated Rootzone Storage\", \"Fastflow storage\", \"Groundwater storage\"]\n", + "param_names = [\"Imax\",\"Ce\", \"Sumax\", \"beta\", \"Pmax\", \"Tlag\", \"Kf\", \"Ks\"]\n", + "\n", + "# set initial as mean of max,min\n", + "par_0 = (p_min_initial + p_max_initial)/2" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "03aea008-87ce-4d09-8d01-f12dfe6bb116", + "metadata": {}, + "outputs": [], + "source": [ + "experiment_start_date = \"1997-08-01T00:00:00Z\"\n", + "experiment_end_date = \"2000-08-31T00:00:00Z\"\n", + "HRU_id = 2479155\n", + "alpha = 1.2626" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "41855c32-2650-403e-bcad-332eab6c1ec4", + "metadata": {}, + "outputs": [], + "source": [ + "from ewatercycle_HBV.forcing import HBVForcing" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6249ec9f-8ff2-4181-ac6f-cac309d8cf72", + "metadata": {}, + "outputs": [], + "source": [ + "test_forcing = HBVForcing(start_time = experiment_start_date,\n", + " end_time = experiment_end_date,\n", + " directory = forcing_path,\n", + " camels_file = f'0{HRU_id}_lump_cida_forcing_leap.txt',\n", + " alpha= alpha\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f5962203-87d3-45dc-acf8-1354522e5fe1", + "metadata": {}, + "outputs": [], + "source": [ + "ds = test_forcing.from_camels_txt()" + ] + }, + { + "cell_type": "markdown", + "id": "7ab1b4e5-c1bf-48d1-a46a-19a7aeb8867c", + "metadata": {}, + "source": [ + "#### Can also run locally when developing - v0.1.1. here\n", + "```py\n", + "from ewatercycle.container import ContainerImage\n", + "LeakyBucket(forcing=forcing, bmi_image=ContainerImage(\"local_image:latest\"))\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9aad16e2-272a-4fe3-a048-0801cbfa4a52", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from ewatercycle.container import ContainerImage\n", + "local_model = LocalModelHBV(forcing=test_forcing)" + ] + }, + { + "cell_type": "markdown", + "id": "b6f86ebb-37ed-4db7-b011-971b8eafbbb0", + "metadata": {}, + "source": [ + "need to add a local container to run" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a6c23e65-f652-444b-9782-238b8ad957a7", + "metadata": {}, + "outputs": [], + "source": [ + "config_file, _ = local_model.setup(\n", + " parameters=','.join([str(p) for p in par_0]),\n", + " initial_storage=','.join([str(s) for s in s_0]),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "33bec934-bd45-4274-9204-3c762564434c", + "metadata": {}, + "outputs": [], + "source": [ + "local_model.initialize(config_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5c67e834-9232-41a3-9e19-216c742e83da", + "metadata": {}, + "outputs": [], + "source": [ + "Q_m = []\n", + "time = []\n", + "while local_model.time < local_model.end_time:\n", + " local_model.update()\n", + " Q_m.append(local_model.get_value(\"Q_m\"))\n", + " time.append(local_model.time_as_datetime.date())" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d6d843b5-08d7-44da-b2ff-098b71091a9c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(time[:-10], Q_m[:-10])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1ff5c18f-7f4d-477b-9dcf-ce85c94c3185", + "metadata": {}, + "outputs": [], + "source": [ + "local_model.finalize()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "2f9ead2b-d0d0-4da5-ae0b-01beeffc44c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parameter_set=None forcing=HBVForcing(start_time='1997-08-01T00:00:00Z', end_time='2000-08-31T00:00:00Z', directory=PosixPath('/home/davidhaasnoot/eWaterCycle-WSL-WIP/Forcing'), shape=None, camels_file='02479155_lump_cida_forcing_leap.txt', pr='HBV_forcing_CAMELS_2024-03-05 14_38.nc', pev='HBV_forcing_CAMELS_2024-03-05 14_38.nc', alpha=1.2626, test_data_bool=False)\n" + ] + } + ], + "source": [ + "print(local_model)" + ] + }, + { + "cell_type": "markdown", + "id": "b944e1b8-e225-483d-b39e-74ed4dea37cf", + "metadata": {}, + "source": [ + "# Containerised" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "555a3c69-953c-403b-a259-125aa8370dd8", + "metadata": {}, + "outputs": [], + "source": [ + "from ewatercycle.models import HBV" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d62a1be2-e5a1-4c82-aaf0-9ab2eeea14af", + "metadata": {}, + "outputs": [], + "source": [ + "image_link = \"ghcr.io/daafip/hbv-bmi-grpc4bmi:v1.2.0\"" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "e58785c1-fe03-4f4f-b00c-ee5754de1bf5", + "metadata": {}, + "outputs": [], + "source": [ + "from ewatercycle.container import ContainerImage\n", + "model = HBV(forcing=test_forcing,bmi_image=ContainerImage(image_link))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ebbd898f-b3cc-4d03-8050-21067d31c1e8", + "metadata": {}, + "outputs": [], + "source": [ + "config_file, _ = model.setup(\n", + " parameters=','.join([str(p) for p in par_0]),\n", + " initial_storage=','.join([str(s) for s in s_0]),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ba14b408-e446-45aa-b406-91dc35f40bc1", + "metadata": {}, + "outputs": [], + "source": [ + "model.initialize(config_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "579fe3d8-0418-4e76-9d66-9c1a938812cc", + "metadata": {}, + "outputs": [], + "source": [ + "Q_m = []\n", + "time = []\n", + "while model.time < model.end_time:\n", + " model.update()\n", + " Q_m.append(model.get_value(\"Q_m\"))\n", + " time.append(pd.Timestamp(model.time_as_datetime.date()))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "a6fd6178-1059-497a-a91f-dd0fa983df2a", + "metadata": {}, + "outputs": [], + "source": [ + "model.finalize()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "ccde9dca-258d-409c-a602-d4abda553b32", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(data=Q_m,columns=[\"Modeled discharge\"],index=time)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "5a1fa61b-97ec-46a7-9fbd-65d415568371", + "metadata": {}, + "outputs": [], + "source": [ + "Q_m_in_ref = np.loadtxt(\"Q_m_out_ref.txt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "a39c2e98-30d0-4658-adbd-b2feae7062f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1)\n", + "df.plot(ax=ax,label=\"Modeled discharge HBV-bmi\")\n", + "# ax.plot(df.index, Q_m_in_ref[1:],ls=\"--\",label=\"Modelled reference Q\");\n", + "# ds[\"Q\"].plot(ax=ax,lw=0,marker=\"*\",ms=2.5,zorder=-1,label=\"Observations\")\n", + "ax.legend(bbox_to_anchor=(1,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "237dc2dd-d1e5-4659-8a66-14ae1187a791", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parameter_set=None forcing=HBVForcing(start_time='1997-08-01T00:00:00Z', end_time='2000-08-31T00:00:00Z', directory=PosixPath('/home/davidhaasnoot/eWaterCycle-WSL-WIP/Forcing'), shape=None, camels_file='02479155_lump_cida_forcing_leap.txt', pr='HBV_forcing_CAMELS_2024-03-05 14_38.nc', pev='HBV_forcing_CAMELS_2024-03-05 14_38.nc', alpha=1.2626, test_data_bool=False)\n" + ] + } + ], + "source": [ + "print(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "538afeb7-8d12-47e2-85f0-f108ad925b45", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/index.rst b/docs/source/index.rst new file mode 100644 index 0000000..2d5d3a2 --- /dev/null +++ b/docs/source/index.rst @@ -0,0 +1,69 @@ +.. eWaterCycle-HBV documentation master file, created by + sphinx-quickstart on Thu Mar 7 10:34:21 2024. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to eWaterCycle-HBV's documentation! +=========================================== + +HBV (Hydrologiska Byråns Vattenbalansavdelning) is a conceptual +hydrological model. For more information on it’s history, see this +`paper `__. + +This current implementation is *without* a snow reservoir. + +This package is based on the `Leaky +bucket `__ +& is a wrapper for the `HBV-bmi `__ +model designed for the `eWaterCycle `_ platform. + +Installation +------------ + +Install this package alongside your eWaterCycle installation + +.. code:: console + + pip install ewatercycle-hbv + +Then HBV becomes available as one of the eWaterCycle models + +.. code:: python + + from ewatercycle.models import HBV + +Implementing your own model +--------------------------- + +For more information on how this plugin works, and on how to implement +your own model see the `plugin +guide `__ + +Changelog +--------- + +Changes can be found in +`CHANGELOG.md `__ +on GitHub + +License +------- + +This is a ``ewatercycle-plugin`` & thus this is distributed under the +same terms as the template: the +`Apache-2.0 `__ license. + +.. toctree:: + :maxdepth: 2 + :caption: Contents: + + example_model_run_HBV + + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search`