{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimal Power Flow via PandaModels\n",
    "### PandaModels.jl: Interfacing PowerModels with pandapower\n",
    "\n",
    "This tutorial describes how to run the Optimal Power Flow via [PandaModels.jl](https://e2niee.github.io/PandaModels.jl/dev/) calling [PowerModels.jl](https://lanl-ansi.github.io/PowerModels.jl/stable/) package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's get started\n",
    "\n",
    "So here is an example of how it works. First, we create a grid in pandapower. Here, we create a meshed 110kV grid with four buses that is fed from an 220kV network through a 3-Winding transformer.\n",
    "Also we need to set min/max values as optimization constarints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "This pandapower network includes the following parameter tables:\n",
       "   - bus (5 elements)\n",
       "   - load (3 elements)\n",
       "   - gen (3 elements)\n",
       "   - line (4 elements)\n",
       "   - trafo3w (1 element)\n",
       "   - poly_cost (3 elements)\n",
       "   - bus_geodata (5 elements)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandapower as pp\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "net = pp.create_empty_network()\n",
    "\n",
    "min_vm_pu = 0.95\n",
    "max_vm_pu = 1.05\n",
    "\n",
    "#create buses\n",
    "bus1 = pp.create_bus(net, vn_kv=220., geodata=(5,9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)\n",
    "bus2 = pp.create_bus(net, vn_kv=110., geodata=(6,10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)\n",
    "bus3 = pp.create_bus(net, vn_kv=110., geodata=(10,9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)\n",
    "bus4 = pp.create_bus(net, vn_kv=110., geodata=(8,8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)\n",
    "bus5 = pp.create_bus(net, vn_kv=110., geodata=(6,8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)\n",
    "\n",
    "#create 220/110/110 kV 3W-transformer\n",
    "pp.create_transformer3w_from_parameters(net, bus1, bus2, bus5, vn_hv_kv=220, vn_mv_kv=110,\n",
    "                                        vn_lv_kv=110, vk_hv_percent=10., vk_mv_percent=10.,\n",
    "                                        vk_lv_percent=10., vkr_hv_percent=0.5,\n",
    "                                        vkr_mv_percent=0.5, vkr_lv_percent=0.5, pfe_kw=10,\n",
    "                                        i0_percent=0.1, shift_mv_degree=0, shift_lv_degree=0,\n",
    "                                        sn_hv_mva=100, sn_mv_mva=50, sn_lv_mva=50)\n",
    "\n",
    "#create 110 kV lines\n",
    "l1 = pp.create_line(net, bus2, bus3, length_km=70., std_type='149-AL1/24-ST1A 110.0')\n",
    "l2 = pp.create_line(net, bus3, bus4, length_km=50., std_type='149-AL1/24-ST1A 110.0')\n",
    "l3 = pp.create_line(net, bus4, bus2, length_km=40., std_type='149-AL1/24-ST1A 110.0')\n",
    "l4 = pp.create_line(net, bus4, bus5, length_km=30., std_type='149-AL1/24-ST1A 110.0')\n",
    "\n",
    "#create loads\n",
    "pp.create_load(net, bus2, p_mw=60)\n",
    "pp.create_load(net, bus3, p_mw=70)\n",
    "pp.create_load(net, bus4, p_mw=10)\n",
    "\n",
    "#create generators\n",
    "g1 = pp.create_gen(net, bus1, p_mw=40, min_p_mw=0, max_p_mw=200, vm_pu=1.01, slack=True)\n",
    "pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1)\n",
    "\n",
    "g2 = pp.create_gen(net, bus3, p_mw=40, min_p_mw=0, max_p_mw=200, vm_pu=1.01)\n",
    "pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=3)\n",
    "\n",
    "g3 = pp.create_gen(net, bus4, p_mw=50, min_p_mw=0, max_p_mw=200, vm_pu=1.01)\n",
    "pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3)\n",
    "net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that PowerModels does not have a 3W-transformer model, but since pandapower includes the equations to calculate the equivalent branches for the 3W-transformers (2W-transformers instead), it is possible to optimize grids with 3W-transformers in PowerModels through the pandapower interface. The same is true for other complex transformer models, switches/breaker, extended ward equivalents etc.\n",
    "\n",
    "Let's have a look at the grid we created with pandapowers plotting module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandapower.plotting as plot\n",
    "%matplotlib inline\n",
    "plot.simple_plot(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's run an OPF through PowerModels and look at the results (Note that the first time the runpm function is called, Julia is started in the background, which may take some time):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot be performed due to [WinError 3] - Can't find file python39.dll\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    pp.runpm_ac_opf(net)\n",
    "except Exception as err:\n",
    "    print(err)\n",
    "\n",
    "\n",
    "# or: pp.runpm(net, pm_model=\"ACPPowerModel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Also, there are further parameters and options that you can add as input while calling the Optimization Problem from PandaModles:\n",
    "\n",
    "| parameter | description | type | default |\n",
    "| :--- | :--- | :---: | :--- |\n",
    "| correct_pm_network_data | checks if network data is correct. If not tries to correct it | bool | True |\n",
    "| silence | Suppresses information and warning messages output by PowerModels | bool | True |\n",
    "| pm_model | PowerModels.jl model to use | str | \"ACPPowerModel\" |\n",
    "| pm_solver | \"main\" solver| str | \"ipopt\" |\n",
    "| pm_mip_solver | mixed integer solver| str | \"cbc\" |\n",
    "| pm_nl_solver | nonlinear solver| str | \"ipopt\" |\n",
    "| pm_tol | default desired convergence tolerance for solver to use | float | 1e-8 |\n",
    "| pm_log_level | solver log level in power models | int | 0 |\n",
    "| delete_buffer_file | If True, the .json file used by PandaModels will be deleted after optimization. | bool | True |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since Generator 1 has the lowest cost, all required power is supplied through this generator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>p_mw</th>\n",
       "      <th>q_mvar</th>\n",
       "      <th>va_degree</th>\n",
       "      <th>vm_pu</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   p_mw  q_mvar  va_degree  vm_pu\n",
       "0   NaN     NaN        NaN    NaN\n",
       "1   NaN     NaN        NaN    NaN\n",
       "2   NaN     NaN        NaN    NaN"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.res_gen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This however leeds to an overload in the three-winding transformer, through which g1 is connected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   NaN\n",
       "Name: loading_percent, dtype: float64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.res_trafo3w.loading_percent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's set some constraints for the 3W-transformer and the lines and rerun the OPF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot be performed due to [WinError 3] - Can't find file python39.dll\n"
     ]
    }
   ],
   "source": [
    "net.trafo3w[\"max_loading_percent\"] = 50\n",
    "net.line[\"max_loading_percent\"] = 20\n",
    "try:\n",
    "    pp.runpm_ac_opf(net)\n",
    "except:\n",
    "    print(\"Cannot be performed due to [WinError 3] - Can't find file python39.dll\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The constraints are complied with for all lines and the 3W transformer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   NaN\n",
       "Name: loading_percent, dtype: float64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.res_trafo3w.loading_percent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0   NaN\n",
       "1   NaN\n",
       "2   NaN\n",
       "3   NaN\n",
       "Name: loading_percent, dtype: float64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.res_line.loading_percent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The power is now generated by a mixture of the generators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>p_mw</th>\n",
       "      <th>q_mvar</th>\n",
       "      <th>va_degree</th>\n",
       "      <th>vm_pu</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   p_mw  q_mvar  va_degree  vm_pu\n",
       "0   NaN     NaN        NaN    NaN\n",
       "1   NaN     NaN        NaN    NaN\n",
       "2   NaN     NaN        NaN    NaN"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.res_gen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing the full functionality of PowerModels.jl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apart from the AC OPF used in the example above, pandapower also has an interface to run the DC OPF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot be performed due to [WinError 3] - Can't find file python39.dll\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>vm_pu</th>\n",
       "      <th>va_degree</th>\n",
       "      <th>p_mw</th>\n",
       "      <th>q_mvar</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   vm_pu  va_degree  p_mw  q_mvar\n",
       "0    NaN        NaN   NaN     NaN\n",
       "1    NaN        NaN   NaN     NaN\n",
       "2    NaN        NaN   NaN     NaN\n",
       "3    NaN        NaN   NaN     NaN\n",
       "4    NaN        NaN   NaN     NaN"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "try:\n",
    "    pp.runpm_dc_opf(net)\n",
    "except:\n",
    "    print(\"Cannot be performed due to [WinError 3] - Can't find file python39.dll\")\n",
    "# or: pp.runpm(net, pm_model=\"DCPPowerModel\")\n",
    "net.res_bus\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The PowerModels data structure that was passed to Julia can be accessed like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': {'index': 1,\n",
       "  'bus_i': 1,\n",
       "  'zone': 1,\n",
       "  'bus_type': 3,\n",
       "  'vmax': 1.05,\n",
       "  'vmin': 0.95,\n",
       "  'va': 0.0,\n",
       "  'vm': 1.01,\n",
       "  'base_kv': 220.0},\n",
       " '2': {'index': 2,\n",
       "  'bus_i': 2,\n",
       "  'zone': 1,\n",
       "  'bus_type': 1,\n",
       "  'vmax': 1.05,\n",
       "  'vmin': 0.95,\n",
       "  'va': 0.0,\n",
       "  'vm': 1.0,\n",
       "  'base_kv': 110.0},\n",
       " '3': {'index': 3,\n",
       "  'bus_i': 3,\n",
       "  'zone': 1,\n",
       "  'bus_type': 2,\n",
       "  'vmax': 1.05,\n",
       "  'vmin': 0.95,\n",
       "  'va': 0.0,\n",
       "  'vm': 1.01,\n",
       "  'base_kv': 110.0},\n",
       " '4': {'index': 4,\n",
       "  'bus_i': 4,\n",
       "  'zone': 1,\n",
       "  'bus_type': 2,\n",
       "  'vmax': 1.05,\n",
       "  'vmin': 0.95,\n",
       "  'va': 0.0,\n",
       "  'vm': 1.01,\n",
       "  'base_kv': 110.0},\n",
       " '5': {'index': 5,\n",
       "  'bus_i': 5,\n",
       "  'zone': 1,\n",
       "  'bus_type': 1,\n",
       "  'vmax': 1.05,\n",
       "  'vmin': 0.95,\n",
       "  'va': 0.0,\n",
       "  'vm': 1.0,\n",
       "  'base_kv': 110.0},\n",
       " '6': {'index': 6,\n",
       "  'bus_i': 6,\n",
       "  'zone': 1,\n",
       "  'bus_type': 1,\n",
       "  'vmax': 1.05,\n",
       "  'vmin': 0.95,\n",
       "  'va': 0.0,\n",
       "  'vm': 1.0,\n",
       "  'base_kv': 220.0}}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net._pm[\"bus\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing the runopp function (that runs an OPF through PYPOWER) and the runpm function shows that PandaModels.jl is much more performant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n",
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n",
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n",
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n",
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n",
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n",
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n",
      "hp.pandapower.run - INFO: These elements have missing power constraint values, which are considered in OPF as +- 1000 TW: ['gen']\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12 s ± 89.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit pp.runopp(net)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot be performed due to [WinError 3] - Can't find file python39.dll\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    %timeit pp.runpm_ac_opf(net)\n",
    "except:\n",
    "    print(\"Cannot be performed due to [WinError 3] - Can't find file python39.dll\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}