doc/eTraGo_tutorial_release0.9.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "__copyright__ = (\n",
    "    \"Flensburg University of Applied Sciences, \"\n",
    "    \"Europa-Universität Flensburg, Centre for Sustainable Energy Systems, \"\n",
    "    \"DLR-Institute for Networked Energy Systems\"\n",
    ")\n",
    "__license__ = \"GNU Affero General Public License Version 3 (AGPL-3.0)\"\n",
    "__author__ = (\n",
    "    \"ulfmueller, lukasol, wolfbunke, mariusves, s3pp, ClaraBuettner, \"\n",
    "    \"CarlosEpia, KathiEsterl, fwitte, gnn, pieterhexen, AmeliaNadal\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"http://etrago.readthedocs.io/en/latest/_images/etrago_logo.png\" alt=\"HSF\" height=\"200\" width=\"200\"  align=\"center\" >\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to eTraGo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Important links\n",
    "\n",
    "* __[eTraGo Source Code](https://github.com/openego/eTraGo)__\n",
    "* __[eTraGo Documentation](http://etrago.readthedocs.io/)__\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation\n",
    "The current eTraGo version as well as the python packages jupyterlab and contextily are required to use this notebook. Install these with\n",
    "\n",
    "`pip install eTraGo`\n",
    "\n",
    "`pip install jupyterlab contextily`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Import required general and eTraGo specific python packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "# enable jupyter interactive plotting\n",
    "%matplotlib widget\n",
    "\n",
    "# import Etrago API class\n",
    "from etrago import Etrago\n",
    "\n",
    "# import plotting function\n",
    "from etrago.tools.plot import plot_carrier\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define parameters to run eTraGo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "args = {\n",
    "    # Setup:\n",
    "    \"db\": \"egon-data\",  # database session\n",
    "    \"scn_name\": \"eGon2035\",  # scenario: eGon2035, eGon100RE, eGon2035_lowflex, eGon100RE_lowflex\n",
    "    \"start_snapshot\": 1,\n",
    "    \"end_snapshot\": 15,\n",
    "    \"gridversion\": None,  # Currently not needed\n",
    "    \"branch_capacity_factor\": {\"HV\": 0.5, \"eHV\": 0.7},  # p.u. branch rating\n",
    "    \"foreign_lines\": {\n",
    "        \"carrier\": \"AC\",  # 'DC' for modeling foreign lines as links\n",
    "        \"capacity\": \"osmTGmod\",  # 'osmTGmod', 'tyndp2020', 'ntc_acer' or 'thermal_acer'\n",
    "    },\n",
    "    \"scn_extension\": None,  # None or array of extension scenarios (currently not provided, but needed once new lines from NEP are set up)\n",
    "    \"scn_decommissioning\": None,  # None or decommissioning scenario (currently not provided)\n",
    "    \n",
    "    # Optimisation and powerflow:\n",
    "    \"method\": {  # Choose method and settings for optimization\n",
    "        \"type\": \"lopf\",  # type of optimization, currently only 'lopf'\n",
    "        \"n_iter\": 1,  # abort criterion of iterative optimization, 'n_iter' or 'threshold'\n",
    "        \"pyomo\": True,  # set if pyomo is used for model building\n",
    "    },\n",
    "    \"solver\": \"gurobi\",  # glpk, cplex or gurobi\n",
    "    \"solver_options\": {\n",
    "        \"BarConvTol\": 1.0e-5,\n",
    "        \"FeasibilityTol\": 1.0e-5,\n",
    "        \"method\": 2,\n",
    "        \"crossover\": 0,\n",
    "        \"logFile\": \"solver_etrago.log\",\n",
    "        \"threads\": 4,\n",
    "    },\n",
    "    \"model_formulation\": \"kirchhoff\",  # formulation of the LPF problem (all are equivalent)\n",
    "    \"extendable\": {\n",
    "        \"extendable_components\": [\n",
    "            \"as_in_db\"\n",
    "        ],  # Array of components to optimize\n",
    "        \"upper_bounds_grid\": {  # Set upper bounds for grid expansion\n",
    "            # lines in Germany\n",
    "            \"grid_max_D\": None,  # relative to existing capacity\n",
    "            \"grid_max_abs_D\": {  # absolute capacity per voltage level\n",
    "                \"380\": {\"i\": 1020, \"wires\": 4, \"circuits\": 4},\n",
    "                \"220\": {\"i\": 1020, \"wires\": 4, \"circuits\": 4},\n",
    "                \"110\": {\"i\": 1020, \"wires\": 4, \"circuits\": 2},\n",
    "                \"dc\": 0,\n",
    "            },\n",
    "            # border crossing lines\n",
    "            \"grid_max_foreign\": 4,  # relative to existing capacity\n",
    "            \"grid_max_abs_foreign\": None,  # absolute capacity per voltage level\n",
    "        },\n",
    "    },\n",
    "    \"generator_noise\": 789456,  # a small random noise to the marginal costs of each generator in order to prevent an optima plateau\n",
    "    \"extra_functionality\": {},  # Choose function name (e.g. \"min_renewable_share\" or \"cross_border_flow\") or {}    \n",
    "    \"load_shedding\": False,  # helpful when debugging - a very expensive generator is added to each bus \n",
    "    \"lpfile\": False,  # save pyomo's lp file: False or /path/to/lpfile.lp\n",
    "    \"csv_export\": \"results\",  # save results as csv: False or /path/tofolder\n",
    "    \"pf_post_lopf\": {\n",
    "        \"active\": True,  # choose if a pf should be performed after the lopf\n",
    "        \"add_foreign_lopf\": True,  # keep results of lopf for foreign DC-links\n",
    "        \"q_allocation\": \"p_nom\",  # allocate reactive power via 'p_nom' or 'p'\n",
    "    },\n",
    "    \n",
    "    # Spatial complexity reduction and disaggregation:\n",
    "    \"network_clustering_ehv\": False,  # clustering of HV buses to EHV buses\n",
    "    \"network_clustering\": {\n",
    "        \"active\": True,  # choose if clustering is activated\n",
    "        \"method\": \"kmedoids-dijkstra\",  # choose clustering method: kmeans or kmedoids-dijkstra\n",
    "        \"n_clusters_AC\": 60,  # total number of resulting AC nodes (DE+foreign)\n",
    "        \"cluster_foreign_AC\": False,  # take foreign AC buses into account, True or False\n",
    "        \"method_gas\": \"kmedoids-dijkstra\",  # choose clustering method: kmeans or kmedoids-dijkstra\n",
    "        \"n_clusters_gas\": 17,  # total number of resulting CH4 nodes (DE+foreign)\n",
    "        \"cluster_foreign_gas\": False,  # take foreign CH4 buses into account, True or False\n",
    "        \"k_elec_busmap\": False,  # False or path/to/busmap.csv\n",
    "        \"k_gas_busmap\": False,  # False or path/to/ch4_busmap.csv\n",
    "        \"bus_weight_tocsv\": None,  # None or path/to/bus_weight.csv\n",
    "        \"bus_weight_fromcsv\": None,  # None or path/to/bus_weight.csv\n",
    "        \"gas_weight_tocsv\": None,  # None or path/to/gas_bus_weight.csv\n",
    "        \"gas_weight_fromcsv\": None,  # None or path/to/gas_bus_weight.csv\n",
    "        \"line_length_factor\": 1,  # Factor to multiply distance between new buses for new line lengths\n",
    "        \"remove_stubs\": False,  # remove stubs bevore kmeans clustering\n",
    "        \"use_reduced_coordinates\": False,  # If True, do not average cluster coordinates\n",
    "        \"random_state\": 42,  # random state for replicability of clustering results\n",
    "        \"n_init\": 10,  # affects clustering algorithm, only change when neccesary\n",
    "        \"max_iter\": 100,  # affects clustering algorithm, only change when neccesary\n",
    "        \"tol\": 1e-6,  # affects clustering algorithm, only change when neccesary\n",
    "        \"CPU_cores\": 4,  # number of cores used during clustering, \"max\" for all cores available.\n",
    "    },\n",
    "    \"sector_coupled_clustering\": {\n",
    "        \"active\": True,  # choose if clustering is activated\n",
    "        \"carrier_data\": {  # select carriers affected by sector coupling\n",
    "            \"central_heat\": {\n",
    "                \"base\": [\"CH4\", \"AC\"],\n",
    "                \"strategy\": \"simultaneous\",  # select strategy to cluster other sectors\n",
    "            },\n",
    "        },\n",
    "    },\n",
    "    \"disaggregation\": None,  # None or 'uniform'\n",
    "    \n",
    "    # Temporal complexity reduction and disaggregation:\n",
    "    \"snapshot_clustering\": {\n",
    "        \"active\": False,  # choose if clustering is activated\n",
    "        \"method\": \"segmentation\",  # 'typical_periods' or 'segmentation'\n",
    "        \"extreme_periods\": None,  # consideration of extreme timesteps; e.g. 'append'\n",
    "        \"how\": \"daily\",  # type of period - only relevant for 'typical_periods'\n",
    "        \"storage_constraints\": \"soc_constraints\",  # additional constraints for storages  - only relevant for 'typical_periods'\n",
    "        \"n_clusters\": 5,  #  number of periods - only relevant for 'typical_periods'\n",
    "        \"n_segments\": 5,  # number of segments - only relevant for segmentation\n",
    "    },\n",
    "    \"skip_snapshots\": 5,  # False or number of snapshots to skip\n",
    "    \"temporal_disaggregation\": {\n",
    "        \"active\": False,  # choose if temporally full complex dispatch optimization should be conducted\n",
    "        \"no_slices\": 8,  # number of subproblems optimization is divided into\n",
    "    },\n",
    "\n",
    "    # Other\n",
    "    \"comments\": None,\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import and export of the network and data structure\n",
    "\n",
    "The network can either be imported from a local database or from an online repository.\n",
    "\n",
    "Follow the instructions [here](https://github.com/openego/eTraGo/tree/features/release-0.9.0#input-data) to get the data-base."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "etrago = Etrago(args, json_path=None)\n",
    "etrago.build_network_from_db()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After importing the network from the database, call `adjust_network` to adjust the network imported from the database according to given input-parameters, e.g. add load shedding, set generator noise, set foreign lines to links."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "etrago.adjust_network()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Etrago uses pypsa's data structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the pypsa network is stored in:\n",
    "etrago.network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.buses.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.buses.carrier.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "etrago.plot_carrier(carrier_links=[\"AC\", \"DC\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "etrago.plot_carrier(carrier_links=[\"CH4\"], carrier_buses=[\"CH4\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To export and import an Etrago network to csv files, you can do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_export = \"etrago_network\"\n",
    "\n",
    "# export\n",
    "etrago.export_to_csv(path_export)\n",
    "\n",
    "# import\n",
    "path_import = \"etrago_network\"\n",
    "etrago_import = Etrago(csv_folder_name=path_import)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Spatial clustering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following arguments define the settings for the spatial clustering:\n",
    "\n",
    "```\n",
    "args = {    \n",
    "    # Spatial complexity reduction and disaggregation:\n",
    "    \"network_clustering_ehv\": False,  # clustering of HV buses to EHV buses\n",
    "    \"network_clustering\": {\n",
    "        \"active\": True,  # choose if clustering is activated\n",
    "        \"method\": \"kmedoids-dijkstra\",  # choose clustering method: kmeans or kmedoids-dijkstra\n",
    "        \"n_clusters_AC\": 60,  # total number of resulting AC nodes (DE+foreign)\n",
    "        \"cluster_foreign_AC\": False,  # take foreign AC buses into account, True or False\n",
    "        \"exclusion_area\": [\"Cuxhaven\", \"Bremerhaven\", \"Wesermarsch\", \"Osterholz\", \"Bremen\"],  # False, path to shapefile or list of nuts names of not cluster area\n",
    "        \"method_gas\": \"kmedoids-dijkstra\",  # choose clustering method: kmeans or kmedoids-dijkstra\n",
    "        \"n_clusters_gas\": 17,  # total number of resulting CH4 nodes (DE+foreign)\n",
    "        \"cluster_foreign_gas\": False,  # take foreign CH4 buses into account, True or False\n",
    "        \"k_elec_busmap\": False,  # False or path/to/busmap.csv\n",
    "        \"k_gas_busmap\": False,  # False or path/to/ch4_busmap.csv\n",
    "        \"bus_weight_tocsv\": None,  # None or path/to/bus_weight.csv\n",
    "        \"bus_weight_fromcsv\": None,  # None or path/to/bus_weight.csv\n",
    "        \"gas_weight_tocsv\": None,  # None or path/to/gas_bus_weight.csv\n",
    "        \"gas_weight_fromcsv\": None,  # None or path/to/gas_bus_weight.csv\n",
    "        \"line_length_factor\": 1,  # Factor to multiply distance between new buses for new line lengths\n",
    "        \"remove_stubs\": False,  # remove stubs bevore kmeans clustering\n",
    "        \"use_reduced_coordinates\": False,  # If True, do not average cluster coordinates\n",
    "        \"random_state\": 42,  # random state for replicability of clustering results\n",
    "        \"n_init\": 10,  # affects clustering algorithm, only change when neccesary\n",
    "        \"max_iter\": 100,  # affects clustering algorithm, only change when neccesary\n",
    "        \"tol\": 1e-6,  # affects clustering algorithm, only change when neccesary\n",
    "        \"CPU_cores\": 8,  # number of cores used during clustering, \"max\" for all cores available.\n",
    "    },\n",
    "    \"sector_coupled_clustering\": {\n",
    "        \"active\": True,  # choose if clustering is activated\n",
    "        \"carrier_data\": {  # select carriers affected by sector coupling\n",
    "            \"central_heat\": {\n",
    "                \"base\": [\"CH4\", \"AC\"],\n",
    "                \"strategy\": \"simultaneous\",  # select strategy to cluster other sectors\n",
    "            },\n",
    "        },\n",
    "    },\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EHV clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.args[\"network_clustering_ehv\"] = True\n",
    "etrago.ehv_clustering()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.plot_carrier(carrier_links=[\"AC\", \"DC\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Network clustering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run clustering of electrical network:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "etrago.spatial_clustering()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "etrago.plot_carrier(carrier_links=[\"AC\", \"DC\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.plot_clusters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.plot_carrier(carrier_links=[\"CH4\"], carrier_buses=[\"CH4\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which bus in the original network corresponds to which bus in the clustered network as well as the original network is stored in `etrago.busmap`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A copy of the main element of the network is stored in:\n",
    "etrago.busmap[\"orig_network\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "pd.Series(etrago.busmap[\"busmap\"]).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run clustering of the gas network and attached technologies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "etrago.spatial_clustering_gas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.plot_carrier(carrier_links=[\"CH4\"], carrier_buses=[\"CH4\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.plot_clusters(carrier=\"CH4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.plot_carrier(carrier_links=[\"central_resistive_heater\", \"central_heat_pump\"], carrier_buses=[\"AC\", \"central_heat\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduce temporal complexity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implemented are:\n",
    "\n",
    "**Downsampling**\n",
    "\n",
    "* time-based method\n",
    "* groups of consecutive time steps are represented by one time step\n",
    "* for each group, one time step is assumed to be representative\n",
    "* this representative time step is weighted according to the number of time steps in its group\n",
    "\n",
    "**Segmentation**\n",
    "\n",
    "* property-based determination of representative time steps\n",
    "* time steps are divided into a certain number of clusters so that similar time steps belong to the same clusters\n",
    "* clusters can have different sizes, i.e. represent segments of different length\n",
    "* only consecutive time steps are placed in the same clusters\n",
    "* for each cluster, a representative time step is defined and weithed based on the number of assigned time steps\n",
    "\n",
    "**Typical periods**\n",
    "\n",
    "* typical periods are identified based on time-dependent attributes\n",
    "* first, the original time series is divided into time periods of equal length\n",
    "* then, the time periods are clustered and representative time periods are selected, which are called typical periods\n",
    "* to model storage behavior correctly, additional constraints are required\n",
    "\n",
    "In case of 'typical periods' and 'segmentation' all load p_set time series as wenn as all renewables p_max_pu time series are used to determine clusters.\n",
    "\n",
    "The following arguments define the settings for the temporal complexity reduction:\n",
    "\n",
    "```\n",
    "args = {    \n",
    "    # Temporal complexity reduction and disaggregation:\n",
    "    \"snapshot_clustering\": {\n",
    "        \"active\": False,  # choose if clustering is activated\n",
    "        \"method\": \"segmentation\",  # 'typical_periods' or 'segmentation'\n",
    "        \"extreme_periods\": None,  # consideration of extreme timesteps; e.g. 'append'\n",
    "        \"how\": \"daily\",  # type of period - only relevant for 'typical_periods'\n",
    "        \"storage_constraints\": \"soc_constraints\",  # additional constraints for storages  - only relevant for 'typical_periods'\n",
    "        \"n_clusters\": 5,  #  number of periods - only relevant for 'typical_periods'\n",
    "        \"n_segments\": 5,  # number of segments - only relevant for 'segmentation'\n",
    "    },\n",
    "    \"skip_snapshots\": 5,  # Downsampling: False or number of snapshots to skip\n",
    "    \"temporal_disaggregation\": {\n",
    "        \"active\": False,  # choose if temporally full complex dispatch optimization should be conducted\n",
    "        \"no_slices\": 8,  # number of subproblems optimization is divided into\n",
    "    },\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'typical_periods' and 'segmentation' are called by the following function\n",
    "#etrago.snapshot_clustering()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.loads_t.p_set.sum(axis=1).to_frame(\"load_p_set\").plot(figsize=(8, 3))\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "etrago.network.snapshots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# run downsampling\n",
    "etrago.skip_snapshots()\n",
    "etrago.network.snapshots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.loads_t.p_set.sum(axis=1).to_frame(\"load_p_set\").plot(figsize=(8, 3))\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weight of each snapshot is given in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.snapshot_weightings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run linear optimal power flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following arguments define the settings for the optimisation:\n",
    "\n",
    "```\n",
    "args = {\n",
    "    \"method\": {  # Choose method and settings for optimization\n",
    "        \"type\": \"lopf\",  # type of optimization, currently only 'lopf'\n",
    "        \"n_iter\": 1,  # abort criterion of iterative optimization, 'n_iter' or 'threshold'\n",
    "        \"pyomo\": True,  # set if pyomo is used for model building\n",
    "    },\n",
    "    \"solver\": \"glpk\",  # glpk, cplex or gurobi\n",
    "    \"solver_options\": {},\n",
    "    \"model_formulation\": \"kirchhoff\",  # formulation of the LPF problem (all are equivalent)\n",
    "    \"extendable\": {\n",
    "        \"extendable_components\": [\n",
    "            \"as_in_db\"\n",
    "        ],  # Array of components to optimize\n",
    "        \"upper_bounds_grid\": {  # Set upper bounds for grid expansion\n",
    "            # lines in Germany\n",
    "            \"grid_max_D\": None,  # relative to existing capacity\n",
    "            \"grid_max_abs_D\": {  # absolute capacity per voltage level\n",
    "                \"380\": {\"i\": 1020, \"wires\": 4, \"circuits\": 4},\n",
    "                \"220\": {\"i\": 1020, \"wires\": 4, \"circuits\": 4},\n",
    "                \"110\": {\"i\": 1020, \"wires\": 4, \"circuits\": 2},\n",
    "                \"dc\": 0,\n",
    "            },\n",
    "            # border crossing lines\n",
    "            \"grid_max_foreign\": 4,  # relative to existing capacity\n",
    "            \"grid_max_abs_foreign\": None,  # absolute capacity per voltage level\n",
    "        },\n",
    "    },\n",
    "    \"generator_noise\": 789456,  # a small random noise to the marginal costs of each generator in order to prevent an optima plateau\n",
    "    \"extra_functionality\": {},  # Choose function name (e.g. \"min_renewable_share\" or \"cross_border_flow\") or {}    \n",
    "    \"load_shedding\": False,  # helpful when debugging - a very expensive generator is added to each bus \n",
    "    \"lpfile\": False,  # save pyomo's lp file: False or /path/to/lpfile.lp\n",
    "    \"csv_export\": \"results\",  # save results as csv: False or /path/tofolder\n",
    "    \"pf_post_lopf\": {\n",
    "        \"active\": True,  # choose if a pf should be performed after the lopf\n",
    "        \"add_foreign_lopf\": True,  # keep results of lopf for foreign DC-links\n",
    "        \"q_allocation\": \"p_nom\",  # allocate reactive power via 'p_nom' or 'p'\n",
    "    },\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#path = \"before_lopf\"\n",
    "#etrago.export_to_csv(path)\n",
    "#etrago = Etrago(csv_folder_name=path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extendable storage units:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.storage_units[etrago.network.storage_units.p_nom_extendable].loc[\n",
    "    :, [\"p_nom\", \"p_nom_min\", \"p_nom_max\", \"p_nom_extendable\", \"carrier\", \"marginal_cost\", \"capital_cost\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.storage_units[etrago.network.storage_units.p_nom_extendable].carrier.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.storage_units.carrier.unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extendable stores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.stores[etrago.network.stores.e_nom_extendable].loc[\n",
    "    :, [\"e_nom\", \"e_nom_min\", \"e_nom_max\", \"e_nom_extendable\", \"carrier\", \"marginal_cost\", \"capital_cost\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.stores[etrago.network.stores.e_nom_extendable].carrier.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.stores.carrier.unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extendable lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.network.lines[etrago.network.lines.s_nom_extendable].loc[\n",
    "    :, [\"s_nom\", \"s_nom_min\", \"s_nom_max\", \"s_nom_extendable\", \"carrier\", \"v_nom\", \"capital_cost\", \"country\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etrago.lopf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the optimisation you can run the following to:\n",
    "\n",
    "* conduct LOPF with full complex time series for dispatch disaggregation\n",
    "\n",
    "```\n",
    "    etrago.dispatch_disaggregation()\n",
    "```\n",
    "\n",
    "* run power flow to obtain reactive power flows over lines\n",
    "\n",
    "```\n",
    "    etrago.pf_post_lopf()\n",
    "```\n",
    "\n",
    "* conduct spatial disaggregation of clustered results\n",
    "\n",
    "```\n",
    "    etrago.disaggregation()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "etrago.plot_grid(line_colors=\"expansion_abs\", bus_colors=\"storage_expansion\", bus_sizes= 0.000001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "etrago.calc_results()\n",
    "etrago.results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from etrago.tools.plot import curtailment, nodal_gen_dispatch, flexibility_usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodal_gen_dispatch(etrago.network)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "curtailment(etrago.network, carrier=\"wind_onshore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flexibility_usage(etrago, \"heat\")"
   ]
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}