examples/notebooks/capacity-expansion-planning-single-node.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "# Single Node Capacity Expansion Planning"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## From electricity market modelling to capacity expansion planning\n",
    "\n",
    "Review the problem formulation of the electricity market model. Below you can find an adapted version\n",
    "where the capacity limits have been promoted to **decision variables** with corresponding terms\n",
    "in the *objective function* and *new constraints for their expansion limits* (e.g. wind and solar potentials). This is known as **capacity expansion problem**.\n",
    "\n",
    "$$\n",
    "\\begin{equation*}\n",
    "    \\min_{g,e,f,G,E,F} \\quad \\sum_{i,s,t} w_t o_{s} g_{i,s,t} + \\sum_{i,s} c_sG_{i,s}  + c_{r,\\text{dis/charge}}G_{i,r, \\text{dis/charge}} +   c_{r}E_{i,r}  + c_\\ell F_{\\ell}\n",
    "  \\end{equation*}\n",
    "$$\n",
    "such that\n",
    "$$\n",
    "  \\begin{align*}\n",
    "    d_{i,t} &= \\sum_s g_{i,s,t}  - \\sum_\\ell K_{i\\ell} f_{\\ell,t}   & \\text{energy balance} \\\\\n",
    "    0 &\\leq g_{i,s,t} \\leq \\hat{g}_{i,s,t} G_{i,s} & \\text{generator limits}\\\\\n",
    "    0 & \\leq g_{i,r,t,\\text{dis/charge}} \\leq G_{i,r,\\text{dis/charge}}& \\text{storage dis/charge limits} \\\\\n",
    "    0 & \\leq e_{i,r,t} \\leq E_{r} & \\text{storage energy limits} \\\\ \n",
    "    e_{i,r,t} &= \\eta^0_{i,r,t} e_{i,r,t-1} + \\eta^1_{r}g_{i,r,t,\\text{charge}} -  \\frac{1}{\\eta^2_{r}} g_{i,r,t,\\text{discharge}} & \\text{storage consistency} \\\\\n",
    "    -F_\\ell &\\leq f_{\\ell,t} \\leq F_\\ell  & \\text{line limits} \\\\\n",
    "    0 &= \\sum_\\ell C_{\\ell c} x_\\ell f_{\\ell,t} & \\text{KVL} \\\\\n",
    "        \\underline{G}_{i,s} & \\leq G_{i,s} \\leq \\overline{G}_{i,s} & \\text{generator capacity expansion limits} \\\\\n",
    "    \\underline{G}_{i,r, \\text{dis/charge}} & \\leq G_{i,r, \\text{dis/charge}} \\leq \\overline{G}_{i,r, \\text{dis/charge}} & \\text{storage power capacity expansion limits} \\\\\n",
    "    \\underline{E}_{i,r} & \\leq E_{i,r} \\leq \\overline{E}_{i,r} & \\text{storage energy expansion limits} \\\\\n",
    "    \\underline{F}_{\\ell} & \\leq F_{\\ell} \\leq \\overline{F}_{\\ell} & \\text{line capacity expansion limits}\n",
    "  \\end{align*}\n",
    "$$\n",
    "\n",
    "**New decision variables for capacity expansion planning:**\n",
    "\n",
    "- $G_{i,s}$ is the generator capacity at bus $i$, technology $s$,\n",
    "- $F_{\\ell}$ is the transmission capacity of line $\\ell$,\n",
    "- $G_{i,r,\\text{dis-/charge}}$ denotes the charge and discharge capacities of storage unit $r$ at bus $i$,\n",
    "- $E_{i,r}$ is the energy capacity of storage $r$ at bus $i$ and time step $t$.\n",
    "\n",
    "**New parameters for capacity expansion planning:**\n",
    "\n",
    "- $c_{\\star}$ is the capital cost of technology $\\star$ at bus $i$\n",
    "- $w_t$ is the weighting of time step $t$ (e.g. number of hours it represents)\n",
    "- $\\underline{G}_\\star, \\underline{F}_\\star, \\underline{E}_\\star$ are the minimum capacities per technology and location/connection.\n",
    "- $\\underline{G}_\\star, \\underline{F}_\\star, \\underline{E}_\\star$ are the maximum capacities per technology and location.\n",
    "\n",
    ":::{note}\n",
    "For a full reference to the optimisation problem description, see https://pypsa.readthedocs.io/en/latest/optimal_power_flow.html\n",
    ":::\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "First things first! We need a few packages for this tutorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T08:46:20.357375Z",
     "start_time": "2024-05-24T08:46:17.846410Z"
    },
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "import pypsa\n",
    "\n",
    "plt.style.use(\"bmh\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Prerequisites: handling technology data and costs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We maintain a database (https://github.com/PyPSA/technology-data) which collects assumptions and projections for energy system technologies (such as costs, efficiencies, lifetimes, etc.) for given years, which we can load into a `pandas.DataFrame`. This requires some pre-processing to load (e.g. converting units, setting defaults, re-arranging dimensions):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:30.201456Z",
     "start_time": "2024-05-24T07:37:29.732485Z"
    }
   },
   "outputs": [],
   "source": [
    "year = 2030\n",
    "url = f\"https://raw.githubusercontent.com/PyPSA/technology-data/master/outputs/costs_{year}.csv\"\n",
    "costs = pd.read_csv(url, index_col=[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:30.218478Z",
     "start_time": "2024-05-24T07:37:30.202899Z"
    }
   },
   "outputs": [],
   "source": [
    "costs.loc[costs.unit.str.contains(\"/kW\"), \"value\"] *= 1e3\n",
    "costs.unit = costs.unit.str.replace(\"/kW\", \"/MW\")\n",
    "\n",
    "defaults = {\n",
    "    \"FOM\": 0,\n",
    "    \"VOM\": 0,\n",
    "    \"efficiency\": 1,\n",
    "    \"fuel\": 0,\n",
    "    \"investment\": 0,\n",
    "    \"lifetime\": 25,\n",
    "    \"CO2 intensity\": 0,\n",
    "    \"discount rate\": 0.07,\n",
    "}\n",
    "costs = costs.value.unstack().fillna(defaults)\n",
    "\n",
    "costs.at[\"OCGT\", \"fuel\"] = costs.at[\"gas\", \"fuel\"]\n",
    "costs.at[\"CCGT\", \"fuel\"] = costs.at[\"gas\", \"fuel\"]\n",
    "costs.at[\"OCGT\", \"CO2 intensity\"] = costs.at[\"gas\", \"CO2 intensity\"]\n",
    "costs.at[\"CCGT\", \"CO2 intensity\"] = costs.at[\"gas\", \"CO2 intensity\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also write a small utility function that calculates the **annuity** to annualise investment costs. The formula is\n",
    "\n",
    "$$\n",
    "a(r, n) = \\frac{r}{1-(1+r)^{-n}}\n",
    "$$\n",
    "where $r$ is the discount rate and $n$ is the lifetime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:30.222911Z",
     "start_time": "2024-05-24T07:37:30.220818Z"
    }
   },
   "outputs": [],
   "source": [
    "def annuity(r, n):\n",
    "    return r / (1.0 - 1.0 / (1.0 + r) ** n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:30.228332Z",
     "start_time": "2024-05-24T07:37:30.223938Z"
    }
   },
   "outputs": [],
   "source": [
    "annuity(0.07, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on this, we can calculate the short-term marginal generation costs (STMGC, €/MWh):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:30.231948Z",
     "start_time": "2024-05-24T07:37:30.229239Z"
    }
   },
   "outputs": [],
   "source": [
    "costs[\"marginal_cost\"] = costs[\"VOM\"] + costs[\"fuel\"] / costs[\"efficiency\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and the annualised investment costs (`capital_cost` in PyPSA terms, €/MW/a):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:30.237265Z",
     "start_time": "2024-05-24T07:37:30.232914Z"
    }
   },
   "outputs": [],
   "source": [
    "annuity = costs.apply(lambda x: annuity(x[\"discount rate\"], x[\"lifetime\"]), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:30.240224Z",
     "start_time": "2024-05-24T07:37:30.238032Z"
    }
   },
   "outputs": [],
   "source": [
    "costs[\"capital_cost\"] = (annuity + costs[\"FOM\"] / 100) * costs[\"investment\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading time series data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are also going to need some time series for wind, solar and load. For now, we are going to recycle the time series we used at the beginning of the course. They are given for Germany in the year 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.705510Z",
     "start_time": "2024-05-24T07:37:30.240941Z"
    }
   },
   "outputs": [],
   "source": [
    "url = (\n",
    "    \"https://tubcloud.tu-berlin.de/s/pKttFadrbTKSJKF/download/time-series-lecture-2.csv\"\n",
    ")\n",
    "ts = pd.read_csv(url, index_col=0, parse_dates=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.730588Z",
     "start_time": "2024-05-24T07:37:33.709003Z"
    }
   },
   "outputs": [],
   "source": [
    "ts.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's convert the load time series from GW to MW, the base unit of PyPSA:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.734128Z",
     "start_time": "2024-05-24T07:37:33.731197Z"
    }
   },
   "outputs": [],
   "source": [
    "ts.load *= 1e3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are also going to adapt the temporal resolution of the time series, e.g. sample only every other hour, to save some time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.742259Z",
     "start_time": "2024-05-24T07:37:33.735104Z"
    }
   },
   "outputs": [],
   "source": [
    "resolution = 4\n",
    "ts = ts.resample(f\"{resolution}h\").first()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple capacity expansion planning example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{note}\n",
    "See also https://model.energy.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In this tutorial, we want to build a replica of [model.energy](https://model.energy).** This tool calculates the cost of meeting a constant electricity demand from a combination of wind power, solar power and storage for different regions of the world.\n",
    "\n",
    "We deviate from [model.energy](https://model.energy) by including offshore wind generation and electricity demand profiles rather than a constant electricity demand. Also, we are going to start with Germany only. You can adapt the code to other countries as an exercise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Initialisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For building the model, we start again by initialising an empty network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.819917Z",
     "start_time": "2024-05-24T07:37:33.743147Z"
    }
   },
   "outputs": [],
   "source": [
    "n = pypsa.Network()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we add a single bus..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.826807Z",
     "start_time": "2024-05-24T07:37:33.820778Z"
    }
   },
   "outputs": [],
   "source": [
    "n.add(\"Bus\", \"electricity\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...and tell the `pypsa.Network` object `n` what the snapshots of the model will be using the utility function `n.set_snapshots()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.834233Z",
     "start_time": "2024-05-24T07:37:33.828849Z"
    }
   },
   "outputs": [],
   "source": [
    "n.set_snapshots(ts.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.839021Z",
     "start_time": "2024-05-24T07:37:33.834898Z"
    }
   },
   "outputs": [],
   "source": [
    "n.snapshots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The weighting of the snapshots (e.g. how many hours they represent, see $w_t$ in problem formulation above) can be set in `n.snapshot_weightings`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.845382Z",
     "start_time": "2024-05-24T07:37:33.840216Z"
    }
   },
   "outputs": [],
   "source": [
    "n.snapshot_weightings.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.849949Z",
     "start_time": "2024-05-24T07:37:33.847259Z"
    }
   },
   "outputs": [],
   "source": [
    "n.snapshot_weightings.loc[:, :] = resolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.855955Z",
     "start_time": "2024-05-24T07:37:33.851011Z"
    }
   },
   "outputs": [],
   "source": [
    "n.snapshot_weightings.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Components"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we add all the technologies we are going to include as carriers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.861842Z",
     "start_time": "2024-05-24T07:37:33.856810Z"
    }
   },
   "outputs": [],
   "source": [
    "carriers = [\n",
    "    \"onwind\",\n",
    "    \"offwind\",\n",
    "    \"solar\",\n",
    "    \"OCGT\",\n",
    "    \"hydrogen storage underground\",\n",
    "    \"battery storage\",\n",
    "]\n",
    "\n",
    "n.add(\n",
    "    \"Carrier\",\n",
    "    carriers,\n",
    "    color=[\"dodgerblue\", \"aquamarine\", \"gold\", \"indianred\", \"magenta\", \"yellowgreen\"],\n",
    "    co2_emissions=[costs.at[c, \"CO2 intensity\"] for c in carriers],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we add the demand time series to the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:33.866618Z",
     "start_time": "2024-05-24T07:37:33.862680Z"
    }
   },
   "outputs": [],
   "source": [
    "n.add(\n",
    "    \"Load\",\n",
    "    \"demand\",\n",
    "    bus=\"electricity\",\n",
    "    p_set=ts.load,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a check whether the data was read-in correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:34.547493Z",
     "start_time": "2024-05-24T07:37:33.867650Z"
    }
   },
   "outputs": [],
   "source": [
    "n.loads_t.p_set.plot(figsize=(6, 2), ylabel=\"MW\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to add one dispatchable generation technology to the model. This is an open-cycle gas turbine (OCGT) with CO$_2$ emissions of 0.2 t/MWh$_{th}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:34.553677Z",
     "start_time": "2024-05-24T07:37:34.549041Z"
    }
   },
   "outputs": [],
   "source": [
    "n.add(\n",
    "    \"Generator\",\n",
    "    \"OCGT\",\n",
    "    bus=\"electricity\",\n",
    "    carrier=\"OCGT\",\n",
    "    capital_cost=costs.at[\"OCGT\", \"capital_cost\"],\n",
    "    marginal_cost=costs.at[\"OCGT\", \"marginal_cost\"],\n",
    "    efficiency=costs.at[\"OCGT\", \"efficiency\"],\n",
    "    p_nom_extendable=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding the variable renewable generators works almost identically, but we also need to supply the capacity factors to the model via the attribute `p_max_pu`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:34.561820Z",
     "start_time": "2024-05-24T07:37:34.554441Z"
    }
   },
   "outputs": [],
   "source": [
    "for tech in [\"onwind\", \"offwind\", \"solar\"]:\n",
    "    n.add(\n",
    "        \"Generator\",\n",
    "        tech,\n",
    "        bus=\"electricity\",\n",
    "        carrier=tech,\n",
    "        p_max_pu=ts[tech],\n",
    "        capital_cost=costs.at[tech, \"capital_cost\"],\n",
    "        marginal_cost=costs.at[tech, \"marginal_cost\"],\n",
    "        efficiency=costs.at[tech, \"efficiency\"],\n",
    "        p_nom_extendable=True,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let's make sure the capacity factors are read-in correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:34.742640Z",
     "start_time": "2024-05-24T07:37:34.562676Z"
    }
   },
   "outputs": [],
   "source": [
    "n.generators_t.p_max_pu.loc[\"2015-03\"].plot(figsize=(6, 2), ylabel=\"CF\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we can already solve the model for the first time. At this stage, the model does not have any storage or emission limits implemented. It's going to look for the least-cost combination of variable renewables and the gas turbine to supply demand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.306567Z",
     "start_time": "2024-05-24T07:37:34.744060Z"
    }
   },
   "outputs": [],
   "source": [
    "n.optimize(solver_name=\"highs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total system cost in billion Euros per year:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.309989Z",
     "start_time": "2024-05-24T07:37:35.307258Z"
    }
   },
   "outputs": [],
   "source": [
    "n.objective / 1e9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimised capacities in GW:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.321024Z",
     "start_time": "2024-05-24T07:37:35.316333Z"
    }
   },
   "outputs": [],
   "source": [
    "n.generators.p_nom_opt.div(1e3)  # GW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total energy generation by technology in GW:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.325340Z",
     "start_time": "2024-05-24T07:37:35.321798Z"
    }
   },
   "outputs": [],
   "source": [
    "n.snapshot_weightings.generators @ n.generators_t.p.div(1e6)  # TWh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we get the objective value through `n.objective`, in many cases we want to know how the costs are distributed across the technologies. We can use the statistics module for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.336635Z",
     "start_time": "2024-05-24T07:37:35.326246Z"
    }
   },
   "outputs": [],
   "source": [
    "(n.statistics.capex() + n.statistics.opex()).div(1e6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Possibly, we are also interested in the total emissions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.340180Z",
     "start_time": "2024-05-24T07:37:35.337550Z"
    }
   },
   "outputs": [],
   "source": [
    "emissions = (\n",
    "    n.generators_t.p\n",
    "    / n.generators.efficiency\n",
    "    * n.generators.carrier.map(n.carriers.co2_emissions)\n",
    ")  # t/h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.344057Z",
     "start_time": "2024-05-24T07:37:35.340740Z"
    }
   },
   "outputs": [],
   "source": [
    "n.snapshot_weightings.generators @ emissions.sum(axis=1).div(1e6)  # Mt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting Optimal Dispatch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function takes the network object `n` as an argument and, optionally, a time frame. We want to plot the load time series, and stacked area charts for electricity feed-in and storage charging. Technologies should be coloured by their color defined in `n.carriers`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.347845Z",
     "start_time": "2024-05-24T07:37:35.344674Z"
    }
   },
   "outputs": [],
   "source": [
    "def plot_dispatch(n, time=\"2015-07\"):\n",
    "    p_by_carrier = n.generators_t.p.groupby(n.generators.carrier, axis=1).sum().div(1e3)\n",
    "\n",
    "    if not n.storage_units.empty:\n",
    "        sto = n.storage_units_t.p.T.groupby(n.storage_units.carrier).sum().T.div(1e3)\n",
    "        p_by_carrier = pd.concat([p_by_carrier, sto], axis=1)\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(6, 3))\n",
    "\n",
    "    color = p_by_carrier.columns.map(n.carriers.color)\n",
    "\n",
    "    p_by_carrier.where(p_by_carrier > 0).loc[time].plot.area(\n",
    "        ax=ax,\n",
    "        linewidth=0,\n",
    "        color=color,\n",
    "    )\n",
    "\n",
    "    charge = p_by_carrier.where(p_by_carrier < 0).dropna(how=\"all\", axis=1).loc[time]\n",
    "\n",
    "    if not charge.empty:\n",
    "        charge.plot.area(\n",
    "            ax=ax,\n",
    "            linewidth=0,\n",
    "            color=charge.columns.map(n.carriers.color),\n",
    "        )\n",
    "\n",
    "    n.loads_t.p_set.sum(axis=1).loc[time].div(1e3).plot(ax=ax, c=\"k\")\n",
    "\n",
    "    plt.legend(loc=(1.05, 0))\n",
    "    ax.set_ylabel(\"GW\")\n",
    "    ax.set_ylim(-200, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oje, that was complicated. Let's test it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.558251Z",
     "start_time": "2024-05-24T07:37:35.348657Z"
    }
   },
   "outputs": [],
   "source": [
    "plot_dispatch(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Storage Units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright, but there are a few important components missing for a system with high shares of renewables? What about short-term storage options (e.g. batteries) and long-term storage options (e.g. hydrogen storage)? Let's add them too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, the battery storage. We are going to assume a fixed energy-to-power ratio of 6 hours, i.e. if fully charged, the battery can discharge at full capacity for 6 hours.\n",
    "For the capital cost, we have to factor in both the capacity and energy cost of the storage. We are also going to enforce a cyclic state-of-charge condition, i.e. the state of charge\n",
    "at the beginning of the optimisation period must equal the final state of charge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.563868Z",
     "start_time": "2024-05-24T07:37:35.559288Z"
    }
   },
   "outputs": [],
   "source": [
    "n.add(\n",
    "    \"StorageUnit\",\n",
    "    \"battery storage\",\n",
    "    bus=\"electricity\",\n",
    "    carrier=\"battery storage\",\n",
    "    max_hours=6,\n",
    "    capital_cost=costs.at[\"battery inverter\", \"capital_cost\"]\n",
    "    + 6 * costs.at[\"battery storage\", \"capital_cost\"],\n",
    "    efficiency_store=costs.at[\"battery inverter\", \"efficiency\"],\n",
    "    efficiency_dispatch=costs.at[\"battery inverter\", \"efficiency\"],\n",
    "    p_nom_extendable=True,\n",
    "    cyclic_state_of_charge=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second, the hydrogen storage. This one is composed of an electrolysis to convert electricity to hydrogen, a fuel cell to re-convert hydrogen to electricity and underground storage (e.g. in salt caverns). We assume an energy-to-power ratio of 168 hours, such that this type of storage can be used for weekly balancing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:35.568599Z",
     "start_time": "2024-05-24T07:37:35.564495Z"
    }
   },
   "outputs": [],
   "source": [
    "capital_costs = (\n",
    "    costs.at[\"electrolysis\", \"capital_cost\"]\n",
    "    + costs.at[\"fuel cell\", \"capital_cost\"]\n",
    "    + 168 * costs.at[\"hydrogen storage underground\", \"capital_cost\"]\n",
    ")\n",
    "\n",
    "n.add(\n",
    "    \"StorageUnit\",\n",
    "    \"hydrogen storage underground\",\n",
    "    bus=\"electricity\",\n",
    "    carrier=\"hydrogen storage underground\",\n",
    "    max_hours=168,\n",
    "    capital_cost=capital_costs,\n",
    "    efficiency_store=costs.at[\"electrolysis\", \"efficiency\"],\n",
    "    efficiency_dispatch=costs.at[\"fuel cell\", \"efficiency\"],\n",
    "    p_nom_extendable=True,\n",
    "    cyclic_state_of_charge=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, lets run the again, now with storage, and see what's changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:37.787634Z",
     "start_time": "2024-05-24T07:37:35.569153Z"
    },
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "n.optimize(solver_name=\"highs\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:37.791962Z",
     "start_time": "2024-05-24T07:37:37.788910Z"
    }
   },
   "outputs": [],
   "source": [
    "n.generators.p_nom_opt  # MW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:37.795694Z",
     "start_time": "2024-05-24T07:37:37.792887Z"
    }
   },
   "outputs": [],
   "source": [
    "n.storage_units.p_nom_opt  # MW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nothing!** The objective value is the same, and no storage is built."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding emission limits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The gas power plant offers sufficient and cheap enough backup capacity to run in periods of low wind and solar generation. But what happens if this source of flexibility disappears. Let's model a 100% renewable electricity system by adding a CO$_2$ emission limit as global constraint:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:37.799340Z",
     "start_time": "2024-05-24T07:37:37.796340Z"
    }
   },
   "outputs": [],
   "source": [
    "n.add(\n",
    "    \"GlobalConstraint\",\n",
    "    \"CO2Limit\",\n",
    "    carrier_attribute=\"co2_emissions\",\n",
    "    sense=\"<=\",\n",
    "    constant=0,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we run the model now..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.394431Z",
     "start_time": "2024-05-24T07:37:37.799959Z"
    },
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "n.optimize(solver_name=\"highs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...and inspect the capacities built..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.399018Z",
     "start_time": "2024-05-24T07:37:45.395494Z"
    }
   },
   "outputs": [],
   "source": [
    "n.generators.p_nom_opt  # MW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.401975Z",
     "start_time": "2024-05-24T07:37:45.399539Z"
    }
   },
   "outputs": [],
   "source": [
    "n.storage_units.p_nom_opt  # MW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.405138Z",
     "start_time": "2024-05-24T07:37:45.402505Z"
    }
   },
   "outputs": [],
   "source": [
    "n.storage_units.p_nom_opt.div(1e3) * n.storage_units.max_hours  # GWh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... we see quite a bit of storage. So how does the optimised dispatch of the system look like?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.751226Z",
     "start_time": "2024-05-24T07:37:45.405789Z"
    }
   },
   "outputs": [],
   "source": [
    "plot_dispatch(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are also keen to see what technologies constitute the largest cost components. For that we're going to define a small helper function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.775316Z",
     "start_time": "2024-05-24T07:37:45.760989Z"
    }
   },
   "outputs": [],
   "source": [
    "def system_cost(n):\n",
    "    tsc = n.statistics.capex() + n.statistics.opex()\n",
    "    return tsc.droplevel(0).div(1e6)  # million €/a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.794492Z",
     "start_time": "2024-05-24T07:37:45.778902Z"
    }
   },
   "outputs": [],
   "source": [
    "system_cost(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This series, we can then process into plots, e.g. a pie chart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.843812Z",
     "start_time": "2024-05-24T07:37:45.795199Z"
    }
   },
   "outputs": [],
   "source": [
    "system_cost(n).plot.pie(figsize=(2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or use to compute the cost per unit of electricity consumed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.848857Z",
     "start_time": "2024-05-24T07:37:45.845406Z"
    }
   },
   "outputs": [],
   "source": [
    "demand = n.snapshot_weightings.generators @ n.loads_t.p_set.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.869432Z",
     "start_time": "2024-05-24T07:37:45.851190Z"
    }
   },
   "outputs": [],
   "source": [
    "system_cost(n).sum() * 1e6 / demand.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:37:45.992885Z",
     "start_time": "2024-05-24T07:37:45.870303Z"
    }
   },
   "outputs": [],
   "source": [
    "n.export_to_netcdf(\"network-new.nc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{warning}\n",
    "Always consider, that the load data is given in units of power (MW) and if your resolution is not hourly, you need to multiply by the snapshot weighting to get the energy consumed!\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Sensitivity Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sensitivity analyses constitute a core activity of energy system modelling. Below, you can find sensitivity analyses regarding the\n",
    "\n",
    "1. variation in allowed CO$_2$ emissions\n",
    "2. variation in solar overnight costs\n",
    "3. variation in offshore wind potentials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:38:23.368274Z",
     "start_time": "2024-05-24T07:37:45.994157Z"
    },
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "sensitivity = {}\n",
    "for co2 in [150, 100, 50, 25, 0]:\n",
    "    n.global_constraints.loc[\"CO2Limit\", \"constant\"] = co2 * 1e6\n",
    "    n.optimize(solver_name=\"highs\")\n",
    "    sensitivity[co2] = system_cost(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:38:23.529678Z",
     "start_time": "2024-05-24T07:38:23.369310Z"
    }
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame(sensitivity).T.div(1e3)  # billion Euro/a\n",
    "df.plot.area(\n",
    "    stacked=True,\n",
    "    linewidth=0,\n",
    "    color=df.columns.map(n.carriers.color),\n",
    "    figsize=(4, 4),\n",
    "    xlim=(0, 150),\n",
    "    xlabel=r\"CO$_2$ emissions [Mt/a]\",\n",
    "    ylabel=\"System cost [bn€/a]\",\n",
    "    ylim=(0, 100),\n",
    ")\n",
    "plt.legend(frameon=False, loc=(1.05, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-24T07:38:23.533051Z",
     "start_time": "2024-05-24T07:38:23.530687Z"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "",
   "language": "python",
   "name": ""
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}