From 49f2008dd51a7f21f36bc5c0834ad18d9de95e41 Mon Sep 17 00:00:00 2001 From: Rolf Hut Date: Sat, 26 Oct 2024 21:40:17 +0200 Subject: [PATCH] renamed notebooks, changed toc, added markdown --- book/_toc.yml | 7 +- book/oneModel/additionalExperiments.md | 8 + .../example_model_run_HBV_CMIP_forcing.ipynb | 635 ++++++++++++++++++ ...pynb => example_model_run_pcrglobwb.ipynb} | 0 4 files changed, 649 insertions(+), 1 deletion(-) create mode 100644 book/oneModel/additionalExperiments.md create mode 100644 book/oneModel/example_model_run_HBV_CMIP_forcing.ipynb rename book/oneModel/pcrglobwb/{model.ipynb => example_model_run_pcrglobwb.ipynb} (100%) diff --git a/book/_toc.yml b/book/_toc.yml index 92f98f3..5cb643d 100644 --- a/book/_toc.yml +++ b/book/_toc.yml @@ -7,4 +7,9 @@ parts: - file: oneModel/oneModel.md sections: - file: oneModel/example_model_run_HBV.ipynb - - file: references.md + - file: oneModel/additionalExperiments.md + sections: + - file: oneModel/pcrglobwb/example_model_run_pcrglobwb.ipynb + - file: oneModel/example_model_run_HBV_CMIP_forcing.ipynb + - file: oneModel/calibration_HBV/example_calibrate_HBV.ipynb + - file: references.md \ No newline at end of file diff --git a/book/oneModel/additionalExperiments.md b/book/oneModel/additionalExperiments.md new file mode 100644 index 0000000..992a9e7 --- /dev/null +++ b/book/oneModel/additionalExperiments.md @@ -0,0 +1,8 @@ +(intro)= +# Additional Experiments + +Next to the simple "run a model" tutorial we provide a number of notebooks to demonstrate more advanced uses of eWaterCycle. The purpose of all these notebooks is to demonstrate what little changes are needed to go from a + +- Generating forcing from CMIP for climate change impact studies. In this notebook we make little changes to the tutorial notebook to not use ERA5 re-analysis data as forcing input, but rather use data from the CMIP models to do climate change impact studies. +- Calibrate a model using observational data. In this notebook we run the tutorial model a thousand times with different parameter sets to find the optimal parameter set linking model output to observations. +- Running a distributed, more complex model. In [this notebook](pcrglobwb/example_model_run_pcrglobwb.ipynb) we run the PCRGlobWB distributed model developed by Utrecht University for a lot of global hydrology studies, focussed on the UK. diff --git a/book/oneModel/example_model_run_HBV_CMIP_forcing.ipynb b/book/oneModel/example_model_run_HBV_CMIP_forcing.ipynb new file mode 100644 index 0000000..bb08ba4 --- /dev/null +++ b/book/oneModel/example_model_run_HBV_CMIP_forcing.ipynb @@ -0,0 +1,635 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e9cd8d85-eb4a-45d6-925a-e3e770592043", + "metadata": {}, + "source": [ + "# Leven at Newby Bridge using HBV model in eWaterCycle\n", + "This notebook demonstrates how eWaterCycle is used to run a model. For the EuroCSDMS workshop we, of course, choose the beautiful region we are in as a case study. River discharge in river Leven is measured at the weirs at Newby Bridge, see the photo below. This observational data is available in the CamelsGB dataset (Coxon 20XX). The larger Caravan (collection of Camels...) dataset is available through eWaterCycle and will be used below.\n", + "\n", + "![image](https://upload.wikimedia.org/wikipedia/commons/7/76/Weirs_on_the_River_Leven_at_Newby_Bridge_-_geograph.org.uk_-_5455774.jpg)\n", + "\n", + "*Weirs on the River Leven at Newby Bridge by G Laird*\n", + "\n", + "As a model we choose the classic [HBV model](https://hess.copernicus.org/articles/26/1371/2022/) for its simplicity. This nicely demonstrates how eWaterCycle works. More complex models are available through eWaterCycle, however:\n", + "\n", + "- these often require parameter sets specific to a region\n", + "- these are more computationally intensive to run and therefore unsuited for a short 45 minute workshop.\n", + "\n", + "Ask us about available models if you want to collaborate! " + ] + }, + { + "cell_type": "markdown", + "id": "e73ddde7-bde3-42e8-991a-8edd4825fd78", + "metadata": {}, + "source": [ + "## Starting up\n", + "To start up, we need to import eWaterCycle and a number of general Python libraries. 'Under the hood' eWaterCycle depends on a large number of other pieces of software, including but not limited to\n", + "\n", + "- [grpc4bmi](https://github.com/eWaterCycle/grpc4bmi), a 'translator' for BMI function calls between different programming languages and across containers. This library was build by the eWaterCycle team, but is available openly for anyone that can benefit from its functionality. \n", + "- apptainer, a container engine that runs the model-containers\n", + "- [ESMValTool](https://github.com/ESMValGroup/ESMValTool), a climate data processing toolbox that originally intended to post-process climate data from CMIP projects for inclusion in IPCC reports, we adopted as tool for pre-processing climate data into forcing data for hydrological models\n", + "- Numerous hydrological models that are made available as plugins to eWaterCycle, see [eWaterCycle-leakybucket](https://github.com/eWaterCycle/ewatercycle-leakybucket) as an example. Note that plugins do not have to be owned and maintained by the eWaterCycle team: anyone with a model can make a plugin for eWaterCycle and make their model be available for others through the platform. \n", + "\n", + "Furthermore, eWaterCycle requires forcing data, obsrvational data and parameter sets to be available to users. If you want to install eWaterCycle on your own infrastructure, see [eWaterCycle-Infra](https://github.com/eWaterCycle/infra) or contact us." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ec7e710a-5aa4-40f9-a1cb-151e3cddbe04", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:32.492461800Z", + "start_time": "2024-03-07T14:21:31.890843300Z" + } + }, + "outputs": [], + "source": [ + "# general python\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "\n", + "import numpy as np\n", + "from pathlib import Path\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import xarray as xr\n", + "\n", + "#niceties\n", + "from rich import print" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4569a0f2-4bea-48cc-b5a4-ca5384e368c6", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.475126400Z", + "start_time": "2024-03-07T14:21:32.537461400Z" + } + }, + "outputs": [], + "source": [ + "# general eWaterCycle\n", + "import ewatercycle\n", + "import ewatercycle.models\n", + "import ewatercycle.forcing" + ] + }, + { + "cell_type": "markdown", + "id": "28ecd862-3e33-4001-9218-d025f6acc2ae", + "metadata": {}, + "source": [ + "## Choose region and time period: \n", + "The HBV model is a lumped hydrological model. It considers a catchment as a homogenious area and calculates the major hydrological processes in it. It requires spatially aggregated rainfall and potential evaporation as inputs (ie. forcings). To calculate its modelled discharge at the outlet of the catchment it also needs a set of parameters. Usually these paramters are calibrated using (historical) observational data, so this is also required. \n", + "\n", + "in eWaterCycle we provide access to the Caravan dataset, which contains all of the above data for all the catchments in the different Camels datasets. However, for two reasons, we don't use the rainfall and potential evaporation data from Caravan\n", + "\n", + "1. This allows us to demonstrate how to generate forcing data for any model from ERA5 (working on ERA5Land) and from CMIP data\n", + "2. There is a known problem with the caravan evaporation data and we want to avoid using it here.\n", + "\n", + "We thus only use the Caravan dataset to retreive \n", + "\n", + "- a shapefile of the region of interest, to be used as input for generating the forcing from ERA5\n", + "- the observational data of river discharge\n", + "\n", + "Using the interactive maps at [eWaterCycle caravan map](https://www.ewatercycle.org/caravan-map/) one can easily retrieve the identifier of the catchment.\n", + "\n", + "Note that changing the region below will work, but that the parameters that are loaded later in this notebook are calibrated specifically for this catchment!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a5898939-54a6-40de-8a27-bbc793536248", + "metadata": {}, + "outputs": [], + "source": [ + "camelsgb_id = \"camelsgb_73010\"" + ] + }, + { + "cell_type": "markdown", + "id": "45b5fc86-ec75-46a8-9f40-4685444628e5", + "metadata": {}, + "source": [ + "We have to specify start and end date of the experiment that we want to do. For now we don't fuzz with diverences between calibration and validation periods (which officially of course is very bad...)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "03aea008-87ce-4d09-8d01-f12dfe6bb116", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.567126600Z", + "start_time": "2024-03-07T14:21:34.567126600Z" + } + }, + "outputs": [], + "source": [ + "experiment_start_date = \"1997-08-01T00:00:00Z\"\n", + "experiment_end_date = \"2000-08-31T00:00:00Z\"" + ] + }, + { + "cell_type": "markdown", + "id": "111bc65b-8299-43ba-95fd-e92df6b92707", + "metadata": {}, + "source": [ + "## Set up paths\n", + "\n", + "Since forcing files are often re-used between experiments it is a best practice to save those intermediate files for re-use between experiments. These logical save-points in workflows are called 'rustpunten' [todo: better english]. It is important to store data in 'rustpunten' in standard formats. Working with clearly defined 'rustpunten' is a key element in the design of good workflows in general and was instrumental in designing eWaterCycle in particular. \n", + "\n", + "Here we set up some paths to store the forcing files we generate in your own home directory. \n", + "\n", + "To speed up this workshop, we have already created the forcing files in a central location, which we also create pointers to here. If you want to run for a different region, you will have to generate the forcing yourself. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "eb5ed837-14aa-4629-b589-ffc33c24ba84", + "metadata": {}, + "outputs": [], + "source": [ + "forcing_path_caravan = Path.home() / \"forcing\" / camelsgb_id / \"caravan\"\n", + "forcing_path_caravan.mkdir(exist_ok=True, parents=True)\n", + "\n", + "prepared_forcing_path_caravan_central = Path(\"/data/eurocsdms-data/forcing/camelsgb_73010/caravan\")\n", + "\n", + "forcing_path_ERA5 = Path.home() / \"forcing\" / camelsgb_id / \"ERA5\"\n", + "forcing_path_ERA5.mkdir(exist_ok=True)\n", + "\n", + "prepared_forcing_path_ERA5_central = Path(\"/data/eurocsdms-data/forcing/camelsgb_73010/ERA5\")" + ] + }, + { + "cell_type": "markdown", + "id": "1171ca7e-d26a-4cbe-abb0-d741315a708c", + "metadata": {}, + "source": [ + "## Generate or load forcing\n", + "There are three options for creating forcing data objects:\n", + "\n", + "- generate from climate data such as ERA5 or CMIP. If the directory you specify as destination already contains data this trying this will throw an error!\n", + "- load forcing data you generated previously by providing the location where it was stored\n", + "- load forcing data someone else (such as Rolf and Bart) generated previously by providing the location where it was stored\n", + "\n", + "First we will create a caravan forcing object, but as mentioned above, we will only use this for the discharge observations and the shape file of the region. After generating the object we show the fields it contains and plot the discharge data. \n", + "\n", + "The actual forcing object we will use in this example is the ERA5 based data.\n", + "\n", + "For both caravan and ERA5 based forcing, only one of the three options provided below should be used, use comments to select which one you want to use." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "19641ae0", + "metadata": {}, + "outputs": [], + "source": [ + "# # option one: generate forcing data\n", + "# camelsgb_forcing = ewatercycle.forcing.sources['CaravanForcing'].generate(\n", + "# start_time=experiment_start_date,\n", + "# end_time=experiment_end_date,\n", + "# directory=forcing_path_caravan,\n", + "# basin_id=camelsgb_id,\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "35875c4f-d5f0-465c-b349-82580dbd71bd", + "metadata": {}, + "outputs": [], + "source": [ + "# option two: load data that you or someone else generated previously\n", + "camelsgb_forcing = ewatercycle.forcing.sources['CaravanForcing'].load(directory=prepared_forcing_path_caravan_central)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2b696cee-5dbe-40de-bafb-6346f6265ff3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
CaravanForcing(\n",
+       "    start_time='1997-08-01T00:00:00Z',\n",
+       "    end_time='2000-08-31T00:00:00Z',\n",
+       "    directory=PosixPath('/data/eurocsdms-data/forcing/camelsgb_73010/caravan'),\n",
+       "    shape=PosixPath('/data/eurocsdms-data/forcing/camelsgb_73010/caravan/camelsgb_73010.shp'),\n",
+       "    filenames={\n",
+       "        'tasmax': 'camelsgb_73010_1997-08-01_2000-08-31_tasmax.nc',\n",
+       "        'evspsblpot': 'camelsgb_73010_1997-08-01_2000-08-31_evspsblpot.nc',\n",
+       "        'Q': 'camelsgb_73010_1997-08-01_2000-08-31_Q.nc',\n",
+       "        'tasmin': 'camelsgb_73010_1997-08-01_2000-08-31_tasmin.nc',\n",
+       "        'pr': 'camelsgb_73010_1997-08-01_2000-08-31_pr.nc',\n",
+       "        'tas': 'camelsgb_73010_1997-08-01_2000-08-31_tas.nc'\n",
+       "    }\n",
+       ")\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1;35mCaravanForcing\u001b[0m\u001b[1m(\u001b[0m\n", + " \u001b[33mstart_time\u001b[0m=\u001b[32m'1997-08-01T00:00:00Z'\u001b[0m,\n", + " \u001b[33mend_time\u001b[0m=\u001b[32m'2000-08-31T00:00:00Z'\u001b[0m,\n", + " \u001b[33mdirectory\u001b[0m=\u001b[1;35mPosixPath\u001b[0m\u001b[1m(\u001b[0m\u001b[32m'/data/eurocsdms-data/forcing/camelsgb_73010/caravan'\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[33mshape\u001b[0m=\u001b[1;35mPosixPath\u001b[0m\u001b[1m(\u001b[0m\u001b[32m'/data/eurocsdms-data/forcing/camelsgb_73010/caravan/camelsgb_73010.shp'\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[33mfilenames\u001b[0m=\u001b[1m{\u001b[0m\n", + " \u001b[32m'tasmax'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_tasmax.nc'\u001b[0m,\n", + " \u001b[32m'evspsblpot'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_evspsblpot.nc'\u001b[0m,\n", + " \u001b[32m'Q'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_Q.nc'\u001b[0m,\n", + " \u001b[32m'tasmin'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_tasmin.nc'\u001b[0m,\n", + " \u001b[32m'pr'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_pr.nc'\u001b[0m,\n", + " \u001b[32m'tas'\u001b[0m: \u001b[32m'camelsgb_73010_1997-08-01_2000-08-31_tas.nc'\u001b[0m\n", + " \u001b[1m}\u001b[0m\n", + "\u001b[1m)\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(camelsgb_forcing)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cc974bcb-5489-4af6-8cf9-cc0299adab97", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#quick plot of the discharge data. \n", + "ds_forcing = xr.open_dataset(camelsgb_forcing['Q'])\n", + "ds_forcing[\"Q\"].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "663be219-1329-4621-8950-b5ef7dde9506", + "metadata": {}, + "outputs": [], + "source": [ + "# option one: generate forcing:\n", + "# ERA5_forcing = ewatercycle.forcing.sources[\"LumpedMakkinkForcing\"].generate(\n", + "# dataset=\"ERA5\",\n", + "# start_time=experiment_start_date,\n", + "# end_time=experiment_end_date,\n", + "# shape=camelsgb_forcing.shape,\n", + "# )\n", + "\n", + "# option two: load data that you or someone else generated previously\n", + "# this is needed because ERA5 forcing data is stored deep in a sub-directory\n", + "load_location = prepared_forcing_path_ERA5_central / \"work\" / \"diagnostic\" / \"script\" \n", + "ERA5_forcing = ewatercycle.forcing.sources[\"LumpedMakkinkForcing\"].load(directory=load_location)" + ] + }, + { + "cell_type": "markdown", + "id": "4787c692-3f9c-402b-9b48-93daeeb47926", + "metadata": {}, + "source": [ + "## Load parameters from calibration" + ] + }, + { + "cell_type": "markdown", + "id": "c4557dc0-b086-4230-8368-ef9b91cb2711", + "metadata": {}, + "source": [ + "The HBV model contains five \"stores\" where the water is stored and nine parameters that control the flow between those stores and in and out of the model.\n", + "We have already calibrated the model for our region of choice and saved the result in a csv file which we load below. If you have changed the region and have calibrated for your region, you need to point to your calibration results here." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ed960ab6-b63a-4664-8306-b57c2ecf27ec", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.528887900Z", + "start_time": "2024-03-07T14:21:34.501125300Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
[\n",
+       "    ('Imax', 7.085),\n",
+       "    ('Ce', 0.837),\n",
+       "    ('Sumax', 76.373),\n",
+       "    ('Beta', 1.112),\n",
+       "    ('Pmax', 0.245),\n",
+       "    ('Tlag', 7.801),\n",
+       "    ('Kf', 0.096),\n",
+       "    ('Ks', 0.003),\n",
+       "    ('FM', 0.226)\n",
+       "]\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m[\u001b[0m\n", + " \u001b[1m(\u001b[0m\u001b[32m'Imax'\u001b[0m, \u001b[1;36m7.085\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Ce'\u001b[0m, \u001b[1;36m0.837\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Sumax'\u001b[0m, \u001b[1;36m76.373\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Beta'\u001b[0m, \u001b[1;36m1.112\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Pmax'\u001b[0m, \u001b[1;36m0.245\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Tlag'\u001b[0m, \u001b[1;36m7.801\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Kf'\u001b[0m, \u001b[1;36m0.096\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'Ks'\u001b[0m, \u001b[1;36m0.003\u001b[0m\u001b[1m)\u001b[0m,\n", + " \u001b[1m(\u001b[0m\u001b[32m'FM'\u001b[0m, \u001b[1;36m0.226\u001b[0m\u001b[1m)\u001b[0m\n", + "\u001b[1m]\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#load calibration constants\n", + "#par_0 = np.loadtxt(\"/data/eurocsdms-data/calibration/calibration_\" + camelsgb_id + \".csv\", delimiter = \",\")\n", + "par_0 = np.loadtxt(\"/home/rhut/configFiles/calibration\" + camelsgb_id + \".csv\", delimiter = \",\")\n", + "\n", + "param_names = [\"Imax\", \"Ce\", \"Sumax\", \"Beta\", \"Pmax\", \"Tlag\", \"Kf\", \"Ks\", \"FM\"]\n", + "print(list(zip(param_names, np.round(par_0, decimals=3))))" + ] + }, + { + "cell_type": "markdown", + "id": "324ab8b0-947b-4116-84d9-e476d46ddd98", + "metadata": {}, + "source": [ + "For the storages we can specify an array of starting values. If you don't the model will start 'empty' and needs some timesteps to 'fill up'. Especially for the rootzone storage it helps to not start empty. Note that all units are in mm:
" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f70032e1-602a-4163-a338-2a3ff6264c00", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.494347400Z", + "start_time": "2024-03-07T14:21:34.484123900Z" + } + }, + "outputs": [], + "source": [ + "# Si, Su, Sf, Ss, Sp\n", + "s_0 = np.array([0, 100, 0, 5, 0])" + ] + }, + { + "cell_type": "markdown", + "id": "ff45d384-3549-414b-b8f2-793399161aaf", + "metadata": {}, + "source": [ + "## Setting up the model\n", + "Below we show the core use of eWaterCycle: to users models are objects. We stay as close as possible to the standard BMI functions, but make sure that under the hood eWaterCycle makes everything run. Getting a model to run requires three steps:\n", + "\n", + "1. creating a model object, an instance of the specific model class. This is provided by the different plugins. At the point of creation, the forcing object that will be used need to be passed to the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d62a1be2-e5a1-4c82-aaf0-9ab2eeea14af", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.569218800Z", + "start_time": "2024-03-07T14:21:34.568127600Z" + } + }, + "outputs": [], + "source": [ + "model = ewatercycle.models.HBV(forcing=ERA5_forcing)" + ] + }, + { + "cell_type": "markdown", + "id": "60c0bd34", + "metadata": {}, + "source": [ + "2. creating a configuration file that contains all the information the model needs to initialize itself.\n", + " The format of the configuration file is very model specific. For example, the HBV configuration file contains information on:\n", + " - the location of forcing files\n", + " - the values of parameters and initial storages" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ebbd898f-b3cc-4d03-8050-21067d31c1e8", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.948731400Z", + "start_time": "2024-03-07T14:21:34.568127600Z" + } + }, + "outputs": [], + "source": [ + "config_file, _ = model.setup(parameters=par_0, initial_storage=s_0)" + ] + }, + { + "cell_type": "markdown", + "id": "cdbb274a", + "metadata": {}, + "source": [ + "3. initializing starts the model container, creates all variables, and basically gets the model primed to start running." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ba14b408-e446-45aa-b406-91dc35f40bc1", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:34.957732500Z", + "start_time": "2024-03-07T14:21:34.953733500Z" + } + }, + "outputs": [], + "source": [ + "model.initialize(config_file)" + ] + }, + { + "cell_type": "markdown", + "id": "1e320191-4ee4-4535-94f3-05e5afef96e2", + "metadata": {}, + "source": [ + "## Running the model\n", + "The basic loop that runs the model calls the ```model.update()``` to have the model progress one timestep and ```model.get_value()``` to extract information of interest. More complex experiment can interact with the model using, for example, ```model.set_value()``` to change values. In this way \n", + "\n", + "- multiple models can interact (including be coupled)\n", + "- models can be adjusted during runtime to incoming observations (ie. data assimilation)\n", + "- Effects not covered by the model can be calculated seperatly and included to create 'what if' experiments.\n", + "- and many more applications." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "579fe3d8-0418-4e76-9d66-9c1a938812cc", + "metadata": { + "ExecuteTime": { + "start_time": "2024-03-07T14:21:34.997729900Z" + } + }, + "outputs": [], + "source": [ + "Q_m = []\n", + "time = []\n", + "while model.time < model.end_time:\n", + " model.update()\n", + " Q_m.append(model.get_value(\"Q\")[0])\n", + " time.append(pd.Timestamp(model.time_as_datetime))" + ] + }, + { + "cell_type": "markdown", + "id": "b2a78bda-4e19-474f-8367-acec10c50f52", + "metadata": {}, + "source": [ + "After running the model we need to call ```model.finalize()``` to shut everything down, including the container. If we don't do this, the container will continue to be active, eating up system memory." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a6fd6178-1059-497a-a91f-dd0fa983df2a", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-07T14:21:35.030728200Z", + "start_time": "2024-03-07T14:21:34.997729900Z" + } + }, + "outputs": [], + "source": [ + "model.finalize()" + ] + }, + { + "cell_type": "markdown", + "id": "9b88262e-c750-4f8e-a602-50c404969690", + "metadata": {}, + "source": [ + "## Process results\n", + "Finally, we use standard python libraries to visualize the results. We put the model output into a pandas Series to make plotting easier." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ccde9dca-258d-409c-a602-d4abda553b32", + "metadata": { + "ExecuteTime": { + "start_time": "2024-03-07T14:21:34.997729900Z" + } + }, + "outputs": [], + "source": [ + "model_output = pd.Series(data=Q_m, name=\"Modelled discharge\", index=time)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "02879a8d-c55f-4a74-a6cf-8154cffb3d0b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Discharge (mm/d)')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_output.plot()\n", + "ds_forcing[\"Q\"].plot(label=\"Observed discharge\")\n", + "plt.legend()\n", + "plt.ylabel(\"Discharge (mm/d)\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84fd5e2b", + "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.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/book/oneModel/pcrglobwb/model.ipynb b/book/oneModel/pcrglobwb/example_model_run_pcrglobwb.ipynb similarity index 100% rename from book/oneModel/pcrglobwb/model.ipynb rename to book/oneModel/pcrglobwb/example_model_run_pcrglobwb.ipynb