tutorials/three_phase_loadflow_tutorial_simple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple 2 bus Example\n",
    "\n",
    "This tutorial shows how to perform three phase load flow in an unbalanced system.\n",
    "<img src=\"pics/Two bus system.png\" width=\"80%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Three phase or unbalanced load flow is performed using the function \n",
    " pp.runpp_3ph(net) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandapower as pp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create Buses\n",
    "After this import we can start by creating an empty network and two 110 kV buses \n",
    "\n",
    "# Create External Grid\n",
    "For negative and zero sequence networks. \n",
    "The following data is needed in addition to a voltage reference.\n",
    "- s_sc_max_mva\n",
    "- rx_max\n",
    "- r0x0_max\n",
    "- x0x_max\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net = pp.create_empty_network(sn_mva = 100 )\n",
    "bus_eg  =  pp.create_bus(net, vn_kv = 110, name = \"Ext. Grid\")\n",
    "bus_load  =  pp.create_bus(net, vn_kv = 110, name = \"Load\")\n",
    "\n",
    "pp.create_ext_grid(net, bus=bus_eg, vm_pu= 1.0, name=\"Grid Connection\",\n",
    "                   s_sc_max_mva=5000,rx_max=0.1,r0x0_max= 0.1,x0x_max=1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating Lines and transformers\n",
    "\n",
    "Just like balanced load flow there are two ways of creating lines and transformers:\n",
    "- Create using a Standard type from standard type library/ Customized standard type\n",
    "- Create directly from parameters\n",
    "\n",
    "# Create element using a Customized Standard type \n",
    "\n",
    "**This is useful for large networks with many lines and transformers**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Line Type created\n",
    "pp.create_std_type(net, {\"r0_ohm_per_km\": 0.0848, \"x0_ohm_per_km\": 0.4649556, \"c0_nf_per_km\":\\\n",
    "    230.6,\"max_i_ka\": 0.963, \"r_ohm_per_km\": 0.0212, \"x_ohm_per_km\": 0.1162389,\n",
    "             \"c_nf_per_km\":  230}, name=\"example_type\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After a Standard type has been created with zero sequence parameters, there are two more steps required:\n",
    "- Create a line using **pp.create_line** with the standard type\n",
    "- Use **pp.add_zero_impedance_parameters** function to insert them into network elements line and trafo from standard types\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# Actual line created with the length of the line in km\n",
    "pp.create_line(net, from_bus = bus_eg, to_bus = bus_load, length_km = 50.0, std_type=\"example_type\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create Unbalanced Load\n",
    "We can create three phase loads by specifying P, Q values in each phase.\n",
    "The default values are set to zero.\n",
    "\n",
    "Connection type of load can be specified while creating a three phase load\n",
    "\n",
    "**'wye' (Default)** - 3 phase phase-earth load\n",
    "\n",
    "**'delta'** - 3 phase delta load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#This function creates an unbalanced load\n",
    "pp.create_asymmetric_load(net, bus_load, p_a_mw=50, q_a_mvar=50, p_b_mw=10, q_b_mvar=15,\n",
    "                   p_c_mw=10, q_c_mvar=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# add_zero_impedance_parameters\n",
    "\n",
    "This function is required when lines and transformers are created using standard types.\n",
    "\n",
    "This adds the zero sequence parameters from standard type to the network elements trafo and line\n",
    "\n",
    "# runpp_3ph\n",
    "\n",
    "This function performs the calculation and returns results in result tables:\n",
    "\n",
    "-res_element_3ph "
   ]
  },
  {
   "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>vm_a_pu</th>\n",
       "      <th>va_a_degree</th>\n",
       "      <th>vm_b_pu</th>\n",
       "      <th>va_b_degree</th>\n",
       "      <th>vm_c_pu</th>\n",
       "      <th>va_c_degree</th>\n",
       "      <th>p_a_mw</th>\n",
       "      <th>q_a_mvar</th>\n",
       "      <th>p_b_mw</th>\n",
       "      <th>q_b_mvar</th>\n",
       "      <th>p_c_mw</th>\n",
       "      <th>q_c_mvar</th>\n",
       "      <th>unbalance_percent</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.967429</td>\n",
       "      <td>-1.051253</td>\n",
       "      <td>1.013028</td>\n",
       "      <td>-119.470654</td>\n",
       "      <td>1.019784</td>\n",
       "      <td>120.471400</td>\n",
       "      <td>55.707739</td>\n",
       "      <td>60.797345</td>\n",
       "      <td>8.779937</td>\n",
       "      <td>-0.880937</td>\n",
       "      <td>9.373928</td>\n",
       "      <td>-11.441666</td>\n",
       "      <td>1.985821</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.749574</td>\n",
       "      <td>-9.010213</td>\n",
       "      <td>1.091380</td>\n",
       "      <td>-124.105792</td>\n",
       "      <td>1.051243</td>\n",
       "      <td>125.894504</td>\n",
       "      <td>-50.000000</td>\n",
       "      <td>-50.000000</td>\n",
       "      <td>-10.000000</td>\n",
       "      <td>-15.000000</td>\n",
       "      <td>-10.000000</td>\n",
       "      <td>-5.000000</td>\n",
       "      <td>6.642212</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    vm_a_pu  va_a_degree   vm_b_pu  va_b_degree   vm_c_pu  va_c_degree  \\\n",
       "0  0.967429    -1.051253  1.013028  -119.470654  1.019784   120.471400   \n",
       "1  0.749574    -9.010213  1.091380  -124.105792  1.051243   125.894504   \n",
       "\n",
       "      p_a_mw   q_a_mvar     p_b_mw   q_b_mvar     p_c_mw   q_c_mvar  \\\n",
       "0  55.707739  60.797345   8.779937  -0.880937   9.373928 -11.441666   \n",
       "1 -50.000000 -50.000000 -10.000000 -15.000000 -10.000000  -5.000000   \n",
       "\n",
       "   unbalance_percent  \n",
       "0           1.985821  \n",
       "1           6.642212  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pp.add_zero_impedance_parameters(net)\n",
    "pp.runpp_3ph(net)\n",
    "net.res_bus_3ph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The convergence of load flow can be checked with the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net['converged']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Bus system with a transformer in between External Grid and Distribution system\n",
    "\n",
    "<img src=\"pics/Three bus system.png\" width=\"80%\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = pp.create_empty_network(sn_mva=100)\n",
    "bus_eg = pp.create_bus(net, 10)\n",
    "bus_lv = pp.create_bus(net, 0.4)\n",
    "bus_load = pp.create_bus(net, 0.4 )\n",
    "\n",
    "pp.create_ext_grid(net, bus_eg, s_sc_max_mva=10000, rx_max=0.1)\n",
    "net.ext_grid[\"r0x0_max\"] = 0.1\n",
    "net.ext_grid[\"x0x_max\"] = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create line and transformer using parameters.\n",
    "\n",
    "Creates a transformer using parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pp.create_transformer_from_parameters(net, hv_bus=bus_eg, lv_bus=bus_lv, \n",
    "                                          sn_mva= 1.6, vn_hv_kv= 10, \n",
    "                                          vn_lv_kv= 0.4, vk_percent= 6, \n",
    "                                          vkr_percent= 0.78125, pfe_kw= 2.7, \n",
    "                                          i0_percent= 0.16875, shift_degree= 0, \n",
    "                                          tap_side= 'lv',tap_neutral= 0,\n",
    "                                          tap_min= -2, tap_max= 2,\n",
    "                                          tap_step_degree= 0,\n",
    "                                          tap_step_percent= 2.5,\n",
    "                                          tap_phase_shifter= False,\n",
    "                                          vk0_percent= 6, vkr0_percent= 0.78125, \n",
    "                                          mag0_percent= 100, mag0_rx= 0.,\n",
    "                                          si0_hv_partial= 0.9,vector_group= \"Dyn\",\n",
    "                                          parallel=1,tap_pos=0,\n",
    "                                          index=pp.get_free_id(net.trafo)+1,\n",
    "                                           )\n",
    "pp.create_line_from_parameters(net, bus_lv, bus_load, length_km=0.5,r_ohm_per_km= 0.1941, x_ohm_per_km= 0.07476991,\n",
    "                    c_nf_per_km= 1160., max_i_ka= 0.421,\n",
    "                    endtemp_degree= 70.0, r0_ohm_per_km= 0.7766,\n",
    "                    x0_ohm_per_km= 0.2990796,\n",
    "                    c0_nf_per_km=  496.2 ,index=pp.get_free_id(net.line)+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create  Asymmetric load\n",
    "\n",
    "Just like before create three phase load with three phase power values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creates a 3 phase wye load\n",
    "pp.create_asymmetric_load(net, bus_load, p_a_mw=0.0300, q_a_mvar=0.0048, p_b_mw=0.0280, q_b_mvar=0.0036,\n",
    "                               p_c_mw=0.027, q_c_mvar=0.0043,type='wye')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run Asymmetric load flow for the network\n",
    "\n",
    "Same as before, add zero sequence parameters and run 3 phase load flow.\n"
   ]
  },
  {
   "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>vm_a_pu</th>\n",
       "      <th>va_a_degree</th>\n",
       "      <th>vm_b_pu</th>\n",
       "      <th>va_b_degree</th>\n",
       "      <th>vm_c_pu</th>\n",
       "      <th>va_c_degree</th>\n",
       "      <th>p_a_mw</th>\n",
       "      <th>q_a_mvar</th>\n",
       "      <th>p_b_mw</th>\n",
       "      <th>q_b_mvar</th>\n",
       "      <th>p_c_mw</th>\n",
       "      <th>q_c_mvar</th>\n",
       "      <th>unbalance_percent</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.000019</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-119.999989</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>120.000007</td>\n",
       "      <td>0.033753</td>\n",
       "      <td>0.005015</td>\n",
       "      <td>0.032228</td>\n",
       "      <td>0.005852</td>\n",
       "      <td>0.032265</td>\n",
       "      <td>0.004113</td>\n",
       "      <td>0.000033</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.998883</td>\n",
       "      <td>-0.209908</td>\n",
       "      <td>0.999048</td>\n",
       "      <td>-120.193661</td>\n",
       "      <td>0.999037</td>\n",
       "      <td>119.813532</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.011346</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.928718</td>\n",
       "      <td>-0.909406</td>\n",
       "      <td>0.945261</td>\n",
       "      <td>-121.399403</td>\n",
       "      <td>0.948863</td>\n",
       "      <td>119.493083</td>\n",
       "      <td>-0.030000</td>\n",
       "      <td>-0.004800</td>\n",
       "      <td>-0.028000</td>\n",
       "      <td>-0.003600</td>\n",
       "      <td>-0.027000</td>\n",
       "      <td>-0.004300</td>\n",
       "      <td>0.214218</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    vm_a_pu  va_a_degree   vm_b_pu  va_b_degree   vm_c_pu  va_c_degree  \\\n",
       "0  1.000000    -0.000019  1.000000  -119.999989  1.000000   120.000007   \n",
       "1  0.998883    -0.209908  0.999048  -120.193661  0.999037   119.813532   \n",
       "2  0.928718    -0.909406  0.945261  -121.399403  0.948863   119.493083   \n",
       "\n",
       "     p_a_mw  q_a_mvar    p_b_mw  q_b_mvar    p_c_mw  q_c_mvar  \\\n",
       "0  0.033753  0.005015  0.032228  0.005852  0.032265  0.004113   \n",
       "1  0.000000  0.000000  0.000000  0.000000  0.000000  0.000000   \n",
       "2 -0.030000 -0.004800 -0.028000 -0.003600 -0.027000 -0.004300   \n",
       "\n",
       "   unbalance_percent  \n",
       "0           0.000033  \n",
       "1           0.011346  \n",
       "2           0.214218  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pp.add_zero_impedance_parameters(net)\n",
    "pp.runpp_3ph(net)\n",
    "net.res_bus_3ph"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}