diff --git a/case3_MARRMOT_calibration_ensemble_RunSavanah.ipynb b/case3_MARRMOT_calibration_ensemble_RunSavanah.ipynb index 2627b60..97bf621 100644 --- a/case3_MARRMOT_calibration_ensemble_RunSavanah.ipynb +++ b/case3_MARRMOT_calibration_ensemble_RunSavanah.ipynb @@ -1,27 +1,666 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "054c676c-b742-4fa0-93a0-539b03c6d133", + "metadata": {}, + "source": [ + "![ewatercycle logo](https://raw.githubusercontent.com/eWaterCycle/ewatercycle/main/docs/examples/logo.png)" + ] + }, + { + "cell_type": "markdown", + "id": "97582468-9dc3-4e7f-8e10-1a3afc869b53", + "metadata": {}, + "source": [ + "# Case study 3: Calibrate Marrmot M14 using GRDC data" + ] + }, + { + "cell_type": "markdown", + "id": "a4b07a2b-5e50-422e-86aa-8f89e89679d4", + "metadata": {}, + "source": [ + "This notebook demostractes how to use a model in eWatercycle, and calibrate it on a catchment (Savannah) and forcing data (ERA5). \n", + "The model used in this notebook is: [MARRMoT](https://github.com/wknoben/MARRMoT) M14 (TOPMODEL)\n", + "We use [CMA Evolution Strategy (CMA-ES) algorithm](https://github.com/CMA-ES/pycma) package for finding the best parameters for the model. The procedure is explained in the cells below." + ] + }, + { + "cell_type": "markdown", + "id": "challenging-classroom", + "metadata": {}, + "source": [ + "Make sure your ewatercycle conda environment is [activated](https://github.com/eWaterCycle/ewatercycle#install)." + ] + }, { "cell_type": "code", "execution_count": 1, + "id": "828160f0-db60-4073-b836-fa2d8952f804", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T07:11:27.278577Z", + "iopub.status.busy": "2021-08-20T07:11:27.277934Z", + "iopub.status.idle": "2021-08-20T07:11:45.877165Z", + "shell.execute_reply": "2021-08-20T07:11:45.877684Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import hashlib\n", + "import time\n", + "import warnings\n", + "from pathlib import Path\n", + "\n", + "import hydrostats.metrics as hm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from cartopy.io import shapereader\n", + "from cftime import date2num\n", + "from matplotlib.ticker import MaxNLocator\n", + "from ruamel.yaml import YAML\n", + "\n", + "import logging\n", + "logging.basicConfig(level=logging.WARNING)\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "\n", + "import cma\n", + "import ewatercycle.models\n", + "from cma.fitness_transformations import EvalParallel2\n", + "from ewatercycle.config import CFG\n", + "from ewatercycle.forcing import load_foreign\n", + "from ewatercycle.observation.grdc import get_grdc_data\n", + "from ewatercycle.util import get_time" + ] + }, + { + "cell_type": "markdown", + "id": "b8cd9aab-8416-44a7-969e-367b092995d1", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-09T15:05:52.535716Z", + "iopub.status.busy": "2021-08-09T15:05:52.535246Z", + "iopub.status.idle": "2021-08-09T15:05:52.537773Z", + "shell.execute_reply": "2021-08-09T15:05:52.537303Z" + } + }, + "source": [ + "General settings:\n", + "Note that we use capitals for 'global' variables.\n", + "Project directories for model input i.e. shape files and forcing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "651bac1f-728b-48b1-a9ab-306164756402", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T07:11:45.883168Z", + "iopub.status.busy": "2021-08-20T07:11:45.882575Z", + "iopub.status.idle": "2021-08-20T07:11:45.884604Z", + "shell.execute_reply": "2021-08-20T07:11:45.885095Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "SHAPE_DIR = Path(\"/projects/0/wtrcycle/comparison/recipes_auxiliary_datasets/Lorentz_Basin_Shapefiles\")\n", + "\n", + "# time range for calibration\n", + "CALIBRATION = {\n", + " 'spinup_start': '1990-01-01T00:00:00Z',\n", + " 'start': '1991-01-01T00:00:00Z',\n", + " 'end': '2001-12-31T00:00:00Z',\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "intensive-marriage", "metadata": {}, + "source": [ + "## 1. Loading forcing data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "experienced-consumption", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T07:11:45.889131Z", + "iopub.status.busy": "2021-08-20T07:11:45.888540Z", + "iopub.status.idle": "2021-08-20T07:11:45.902396Z", + "shell.execute_reply": "2021-08-20T07:11:45.902919Z" + } + }, "outputs": [], "source": [ - "#TODO: everyting ;-)." + "FORCING = load_foreign('marrmot',\n", + " directory='/projects/0/wtrcycle/comparison/forcing/marrmot-m01',\n", + " start_time=CALIBRATION['spinup_start'],\n", + " end_time=CALIBRATION['end'],\n", + " forcing_info={\n", + " 'forcing_file': 'marrmot-m01_ERA5_Savannah_1990_2001.mat'\n", + " })" + ] + }, + { + "cell_type": "markdown", + "id": "expired-oxford", + "metadata": {}, + "source": [ + "## 2. Loading eWaterCycle configuration file\n", + "\n", + "Config settings on Cartesius:\n", + "``` yaml\n", + "grdc_location: '/projects/0/wtrcycle/comparison/GRDC/GRDC_GCOSGTN-H_27_03_2019'\n", + "container_engine: 'singularity'\n", + "singularity_dir: '/scratch/shared/ewatercycle/case3_marrmot14'\n", + "output_dir: '/scratch/shared/ewatercycle/case3_marrmot14'\n", + "```" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, + "id": "wooden-walnut", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T07:11:45.907010Z", + "iopub.status.busy": "2021-08-20T07:11:45.906199Z", + "iopub.status.idle": "2021-08-20T07:11:45.910968Z", + "shell.execute_reply": "2021-08-20T07:11:45.910439Z" + } + }, + "outputs": [], + "source": [ + "CFG.load_from_file('./ewatercycle.yaml')" + ] + }, + { + "cell_type": "markdown", + "id": "c99bfe61-b501-4826-a130-f59836b9d3c6", + "metadata": {}, + "source": [ + "## 3. Functions for calibration\n", + "\n", + "These functions can be used to perform the calibration of the model. The function `objective_function()` can be used as first argument to the optimization methods. As optimization metric we use that Nash–Sutcliffe model efficiency coefficient (NSE), comparing the model output with GRDC data. NSE values range between `-inf < NSE < 1` with close to 1 indicating a good match, while the optimization expects the closer to zero the better. Therefore we use the value `1 - nse_value` as objective function.\n", + "\n", + "### Calibration\n", + "\n", + "We use the [CMA Evolution Strategy (CMA-ES) algorithm](https://github.com/CMA-ES/pycma) package.\n", + "The CMA-ES is initialized with:\n", + "\n", + " - initial value (mean) x0 = 7 * [5], here 7 is the number of variables, 5 is the mean value in range [0, 10].\n", + " - initial step size (standard deviation) sigma0=2.0.\n", + " - options\n", + "\n", + "The values for `bounds` and `sigma0` are chosen based on the guides in\n", + "[practical hints](http://cma.gforge.inria.fr/cmaes_sourcecode_page.html#practical),\n", + "see sections **Encoding of Variables** and **Initial Values**.\n", + "The `bounds` are used to make the `transform` function, see below.\n", + "\n", + "For more information about `parallel processing` see the\n", + "[API documention](http://cma.gforge.inria.fr/apidocs-pycma/cma.fitness_transformations.EvalParallel2.html),\n", + "and about `ask-and-tell interface` see an example at https://pypi.org/project/cma/.\n", + "\n", + "### Practical hints\n", + "The `run_model()` function uses two CPU cores (model-octave, and bmi-server)\n", + "and takes about 4 min to run the model for the CALIBRATION period.\n", + "There are 24 cores available in a `normal` partition on Cartesius.\n", + "If you want to keep the running time to 4 min for e.g. CALIBRATION, you can\n", + "have 12 runs simultaneously. Therefore, the `popsize:12` in the cma-es option.\n", + "If you want to get the results of the whole notebook after a\n", + "reasenable amount of time, you can change `maxiter` in the cma-es option." + ] + }, + { + "cell_type": "markdown", + "id": "e121ee14-a857-47cd-a117-dc6c4256aa70", + "metadata": {}, + "source": [ + "Here, we can set `popsize` and `maxiter` in the cma-es options:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "94a695a3-924b-4bb0-befb-a673f6be15cc", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T07:11:45.914767Z", + "iopub.status.busy": "2021-08-20T07:11:45.914190Z", + "iopub.status.idle": "2021-08-20T07:11:45.916062Z", + "shell.execute_reply": "2021-08-20T07:11:45.916529Z" + } + }, + "outputs": [], + "source": [ + "POPSIZE = 18 # it can be equal to number of available cores/2\n", + "MAXITER = 50 # with this, the notebook takes ~4 hours (maximum)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "separate-unemployment", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T07:11:45.932101Z", + "iopub.status.busy": "2021-08-20T07:11:45.918970Z", + "iopub.status.idle": "2021-08-20T07:11:45.934046Z", + "shell.execute_reply": "2021-08-20T07:11:45.934513Z" + } + }, + "outputs": [], + "source": [ + "def run_model(parameters):\n", + " \"\"\"Setup and run model.\"\"\"\n", + " model = ewatercycle.models.MarrmotM14(version='2020.11', forcing=FORCING)\n", + " \n", + " # Generate a random tag for work_dir name\n", + " # Each work_dir is used by one worker in multiprocessing\n", + " tag = hashlib.md5(str(parameters).encode('utf-8')).hexdigest()\n", + " work_dir = CFG['output_dir'] / f\"marrmot-m14_{tag}\"\n", + " \n", + " cfg_file, cfg_dir = model.setup(\n", + " cfg_dir=work_dir,\n", + " maximum_soil_moisture_storage=parameters[0],\n", + " threshold_flow_generation_evap_change=parameters[1],\n", + " leakage_saturated_zone_flow_coefficient=parameters[2],\n", + " zero_deficit_base_flow_speed=parameters[3],\n", + " baseflow_coefficient=parameters[4],\n", + " gamma_distribution_chi_parameter=parameters[5],\n", + " gamma_distribution_phi_parameter=parameters[6],\n", + " initial_upper_zone_storage=0.9*parameters[0],\n", + " initial_saturated_zone_storage=0.9*parameters[0],\n", + " start_time=CALIBRATION['spinup_start'],\n", + " end_time=CALIBRATION['end'],\n", + " )\n", + " \n", + " # Initialize the model inside the docker container through GRPC4bmi\n", + " model.initialize(cfg_file)\n", + " \n", + " # Convert start to date number to be used in if statement\n", + " start_time = date2num(\n", + " get_time(CALIBRATION['start']),\n", + " model.time_units\n", + " )\n", + " simulated_discharge = []\n", + " end_time = model.end_time\n", + " # Perform all timesteps of the model, update output fields\n", + " while (model.time < end_time):\n", + " model.update()\n", + " # Store model time and variable output after the spin up period\n", + " if model.time >= start_time:\n", + " simulated_discharge.append(model.get_value('flux_out_Q')[0])\n", + " model.finalize()\n", + " return np.array(simulated_discharge)\n", + "\n", + "\n", + "def get_catchment_area(catchment):\n", + " \"\"\"Get the catchment area in m2.\"\"\"\n", + " shapefile = SHAPE_DIR / catchment / f'{catchment}.shp'\n", + " shape = shapereader.Reader(shapefile)\n", + " attr = next(shape.records())\n", + " return attr.attributes['SUB_AREA'] * 1e6\n", + "\n", + "\n", + "def get_observations(station_id):\n", + " \"\"\"Get GRDC observation data.\"\"\"\n", + " observations, metadata = get_grdc_data(station_id, CALIBRATION[\"start\"], CALIBRATION[\"end\"])\n", + " return observations['streamflow']\n", + "\n", + "\n", + "def objective_function(parameters, observation, area):\n", + " \"\"\"Calculate objective function.\n", + "\n", + " Runs the model, converts the output to GRDC streamflow units\n", + " and calculates NSE from simulation data with observation data.\n", + " This is the function that is going to be optimized by scipy.brute.\n", + " \"\"\"\n", + " simulation = run_model(parameters)\n", + " # flux_out_Q unit conversion factor from mm/day to m3/s\n", + " conversion = 1 / (1000 * 86400)\n", + " # convert simulated streamflow to same units as observation\n", + " simulation = simulation * area * conversion\n", + " nse_value = hm.nse(simulation, observation)\n", + " return 1 - nse_value\n", + "\n", + "\n", + "def transform(scaled_parameters):\n", + " \"\"\"Transforms the scaled_parameter to parameter.\n", + "\n", + " if x = scaled_parameter and y = parameter,\n", + " then x is in the range [0, 10] and y is in the range [a, b].\n", + " To map the values [0, 10] into [a, b],\n", + " we use the transformations a + (b-a) * x/10.\n", + " For more information on this transformation,\n", + " please see\n", + " http://cma.gforge.inria.fr/cmaes_sourcecode_page.html#practical\n", + " \"\"\"\n", + " parameters = []\n", + " for scaled_parameter, bound in zip(scaled_parameters, PARAMETERS_BOUNDS):\n", + " scale = (bound[1] - bound[0]) / 10.0\n", + " parameter = bound[0] + (scale * scaled_parameter)\n", + " parameters.append(parameter)\n", + " return parameters\n", + "\n", + "\n", + "def wrapped_objective_function(scaled_parameters, *args):\n", + " \"\"\"A wrapper around the objective function.\n", + "\n", + " The wrapper transforms the scaled_parameters before\n", + " the actual function call.\n", + " \"\"\"\n", + " parameters = transform(scaled_parameters)\n", + " return objective_function(parameters, *args)\n", + "\n", + "\n", + "def run_calibration(parameter_bounds, observation, area):\n", + " \"\"\"Return the optimum parameters found by CMA-ES method.\"\"\"\n", + " # Set some options for optimization needed when multiprocessing\n", + " options = cma.CMAOptions()\n", + " options.set({\n", + " 'bounds': [0, 10], # for scaled parameters\n", + " 'seed': 1234, # set a seed to reproduce results\n", + " 'verbose': -9, # verbosity of initial/final message: maximally quiet\n", + " 'popsize': POPSIZE,\n", + " 'maxiter': MAXITER,\n", + " 'tolfun': 1e-17, # very small value due to model creeping behavior\n", + " 'tolx': 1e-5,\n", + " 'verb_filenameprefix': str(CFG['output_dir']), # cma-es output path\n", + " })\n", + "\n", + " no_of_variables = len(parameter_bounds)\n", + " # initial mean value and standard deviation\n", + " x0 = 5.0\n", + " sigma0 = 2.0\n", + "\n", + " # Initialize the CMA-ES\n", + " cma_es = cma.CMAEvolutionStrategy(no_of_variables * [x0], sigma0, options)\n", + "\n", + " # Store the results of each iteration\n", + " all_scores = []\n", + " all_parameters = []\n", + " \n", + " # Use parallel processing\n", + " with EvalParallel2(number_of_processes=options['popsize']) as evaluations:\n", + " # Use ask-and-tell interface\n", + " while not cma_es.stop():\n", + " solutions = cma_es.ask()\n", + " cma_es.tell(\n", + " solutions,\n", + " evaluations(\n", + " solutions,\n", + " fitness_function=wrapped_objective_function,\n", + " args=(observation, area)\n", + " ),\n", + " )\n", + " # Use transform to return parameters and not scaled ones\n", + " all_parameters.append(transform(cma_es.best.last.x))\n", + " all_scores.append(cma_es.best.last.f)\n", + " print(f\"---- CMA-ES stopped due to: {cma_es.stop()} ----\")\n", + "\n", + " # Make full output\n", + " full_output = (transform(cma_es.result.xbest),\n", + " cma_es.result.fbest,\n", + " all_parameters,\n", + " all_scores)\n", + " return full_output" + ] + }, + { + "cell_type": "markdown", + "id": "lined-python", + "metadata": {}, + "source": [ + "## 4. Running the calibration" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "indie-separate", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T07:11:45.939046Z", + "iopub.status.busy": "2021-08-20T07:11:45.938458Z", + "iopub.status.idle": "2021-08-20T11:06:46.718387Z", + "shell.execute_reply": "2021-08-20T11:06:46.718814Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "E0820 10:17:31.400391063 10222 backup_poller.cc:119] run_poller: {\"created\":\"@1629447451.400369581\",\"description\":\"Timer list shutdown\",\"file\":\"src/core/lib/iomgr/timer_generic.cc\",\"file_line\":297}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---- CMA-ES stopped due to: {'maxiter': 50} ----\n", + "Calibration is completed in 14100.367342948914 seconds\n" + ] + } + ], + "source": [ + "# M14 parameter bounds\n", + "PARAMETERS_BOUNDS = [[1.0, 2000.0],\n", + " [0.05, 0.95],\n", + " [0.0, 1.0],\n", + " [0.1, 200.0],\n", + " [0.0, 1.0],\n", + " [1.0, 7.5],\n", + " [0.1, 5.0]]\n", + "\n", + "observation = get_observations('4148650')\n", + "area = get_catchment_area('Savannah') \n", + "exec_start_time = time.time()\n", + "full_output = run_calibration(PARAMETERS_BOUNDS, observation, area)\n", + "print(f\"Calibration is completed in {time.time() - exec_start_time} seconds\")" + ] + }, + { + "cell_type": "markdown", + "id": "a0ece587-8147-49ad-ac1b-a3772ec7f06d", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-09T18:35:28.457881Z", + "iopub.status.busy": "2021-08-09T18:35:28.457398Z", + "iopub.status.idle": "2021-08-09T18:35:28.540360Z", + "shell.execute_reply": "2021-08-09T18:35:28.539954Z" + } + }, + "source": [ + "Saving model parameters obtained by optimization in a yml file" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "22dca4ac-e0ce-4963-802d-9b3d892c4da6", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T11:06:46.726584Z", + "iopub.status.busy": "2021-08-20T11:06:46.726105Z", + "iopub.status.idle": "2021-08-20T11:06:46.765383Z", + "shell.execute_reply": "2021-08-20T11:06:46.765788Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calibration results saved in /nfs/home6/verhoes/technicalPaperExampleNotebooks/out/marrmot-m14_ERA5_Savannah_calibration_1991-01-01T00:00:00Z_2001-12-31T00:00:00Z.yml\n" + ] + } + ], + "source": [ + "best_par, best_score, pars, scores = full_output\n", + "\n", + "# Use float () to convert to plain Python types\n", + "other_values = [\n", + " ([float(z) for z in x], float(1 - y)) for x, y in zip(pars, scores)\n", + "]\n", + "results_doc = {\n", + " 'title': 'MARRMoT m14 model optimized parameter based on NSE',\n", + " 'best_parameter_value': [float(x) for x in best_par],\n", + " 'best_NSE_value': float(1 - best_score),\n", + " 'other_values': other_values,\n", + "}\n", + "\n", + "# it is saved in the output directory\n", + "filename = f\"{CFG['output_dir']}/marrmot-m14_ERA5_Savannah_calibration_{CALIBRATION['start']}_{CALIBRATION['end']}.yml\" \n", + "yaml = YAML()\n", + "yaml.default_flow_style = False\n", + "with open(filename, 'w+') as f:\n", + " yaml.dump(results_doc, f)\n", + "print(f'Calibration results saved in {filename}')" + ] + }, + { + "cell_type": "markdown", + "id": "hourly-rachel", "metadata": {}, + "source": [ + "## 5. Plotting the optimization results" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "physical-wyoming", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T11:06:46.773710Z", + "iopub.status.busy": "2021-08-20T11:06:46.773220Z", + "iopub.status.idle": "2021-08-20T11:06:46.774978Z", + "shell.execute_reply": "2021-08-20T11:06:46.775365Z" + }, + "tags": [] + }, "outputs": [], "source": [ - "#TODO: but serious: this should copy from the comparison work and calibrate MARRMoT M14 (topmodel) for the Savanah" + "def plot_parameters(results):\n", + " \"\"\"Make a plot showing optimization results.\"\"\"\n", + " \n", + " # Create a figure with left and right axis\n", + " fig, ax = plt.subplots(figsize=(10, 6), dpi=120)\n", + "\n", + " # Plot NSE vs. iteration index obtained by calibration\n", + " label_text = {}\n", + " data = results[\"other_values\"]\n", + " all_parameters, all_scores = list(zip(*data))\n", + " ax.plot(range(1, len(all_scores) + 1), all_scores)\n", + "\n", + " # Add parameters of each iteration as a text\n", + " iterations = []\n", + " for iteration, parameters in enumerate(all_parameters):\n", + " parameters_as_str = ', '.join(f'{par:.2f}' for par in parameters)\n", + " iterations.append(f\"{iteration + 1}: {parameters_as_str}\")\n", + " label_text = '\\n'.join(iterations)\n", + "\n", + " ax.set_xlabel(\"Iteration\", fontsize=12)\n", + " ax.set_ylabel(\"NSE\", fontsize=12)\n", + " ax.set_title(\"Model: MARRMoT m14, Catchment: Savannah\", loc=\"left\")\n", + " ax.xaxis.set_major_locator(MaxNLocator(integer=True)) # x-axis is integer\n", + "\n", + " # Combine and plot legend\n", + " lines, labels = ax.get_legend_handles_labels()\n", + " ax.legend(lines, labels, loc='lower right', prop={\"size\": 8})\n", + "\n", + " # Add statistics\n", + " best_parameters = ', '.join(\n", + " f\"{par:.2f}\" for par in results['best_parameter_value']\n", + " )\n", + " statistics = \"\\n\".join(\n", + " [\n", + " f\"best NSE value: {results['best_NSE_value']:.2f}\",\n", + " f\"best parameters: {best_parameters}\",\n", + " \"-------------------------------\",\n", + " \"Iterations, parameters\",\n", + " f\"{label_text}\",\n", + " ]\n", + " )\n", + "\n", + " box = {\"edgecolor\": \"blue\", \"facecolor\": \"white\"}\n", + " ax.text(\n", + " 1.06,\n", + " 0.98,\n", + " statistics,\n", + " transform=ax.transAxes,\n", + " va=\"top\",\n", + " bbox=box,\n", + " fontsize=6,\n", + " )\n", + "\n", + " # Show grid\n", + " plt.grid(True)\n", + "\n", + " # Fix legend falling off figure\n", + " fig.tight_layout()\n", + " plt.show()\n", + "\n", + " return fig" ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d1f73a0d-95df-4836-8915-0cc9eb150602", + "metadata": { + "execution": { + "iopub.execute_input": "2021-08-20T11:06:46.819482Z", + "iopub.status.busy": "2021-08-20T11:06:46.788925Z", + "iopub.status.idle": "2021-08-20T11:06:47.805538Z", + "shell.execute_reply": "2021-08-20T11:06:47.805910Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# it is located in the output directory\n", + "filename = f\"{CFG['output_dir']}/marrmot-m14_ERA5_Savannah_calibration_{CALIBRATION['start']}_{CALIBRATION['end']}.yml\" \n", + "with open(filename) as f:\n", + " calibration_results = yaml.load(f)\n", + "fig = plot_parameters(calibration_results)\n", + "fig.savefig(f\"{filename}.png\", bbox_inches=\"tight\", dpi=300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "royal-living", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -35,9 +674,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.9.2" } }, "nbformat": 4, - "nbformat_minor": 4 + "nbformat_minor": 5 }