{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kurzschlussberechnung nach IEC 60909"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In diesem Tutorial möchten wir Ihnen vorstellen, wie Sie in pandapower eine Kurzschlussberechnung umsetzen können. Hierbei wird gemäß IEC 60909 eine Kurzschlussberechnung derart umgesetzt, dass an der Fehlerstelle mit einer Ersatzspannungsquelle gerechnet wird. Umgesetzt ist dies für folgende Komponenten:\n",
    "- sgen (as motor or as full converter generator)\n",
    "- gen (as synchronous generator)\n",
    "- ext_grid\n",
    "- line\n",
    "- trafo\n",
    "- trafo3w\n",
    "- impedance\n",
    "\n",
    "mit den jeweiligen Korrekturfaktoren, die in IEC 60909 definiert sind. Lasten und Shunts werden, entsprechend der Norm, hierbei vernachlässigt. Das Schaltermodell ist komplett in die Berechnung übertragbar.\n",
    "\n",
    "Folgende Kurzschlusströme werden berechnet:\n",
    "- ikss (Anfangs-Kurzschlusswechselstrom)\n",
    "- ip (Stoß-Kurzschlussstrom)\n",
    "- ith (Thermisch gleichwertiger Kurzschlussstrom)\n",
    "\n",
    "entweder als:\n",
    "- symmetrisch dreiphasiger oder\n",
    "- asymmetrisch zweiphasiger\n",
    "\n",
    "Kurzschlussstrom. \n",
    "\n",
    "Berechnungen sind möglich für vermaschte und radiale Netze. ip und ith wurden nur implementiert für Kurzschlussströme weit von Synchrongeneratoren entfernt.\n",
    "\n",
    "Alle Ergebnisse wurden gegenüber gängiger Softwaretools am Markt getestet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispielnetz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um die Kurzschlussberechnung zu zeigen, definieren wir uns zuerste ein einfaches, offen-ringbetriebes Netz mit 4 Bussen, welche untereinander über zwei Leitungen und einem Transformator verbunden sind. Ein offner Schalter gewährleistet, dass das Netz unvermascht, offen betrieben wird.\n",
    "\n",
    "<img src=\"shortcircuit/example_network_sc.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandapower as pp\n",
    "import pandapower.shortcircuit as sc\n",
    "\n",
    "def ring_network():\n",
    "    net = pp.create_empty_network()\n",
    "    b1 = pp.create_bus(net, 220)\n",
    "    b2 = pp.create_bus(net, 110)\n",
    "    b3 = pp.create_bus(net, 110)\n",
    "    b4 = pp.create_bus(net, 110)\n",
    "    pp.create_ext_grid(net, b1, s_sc_max_mva=100., s_sc_min_mva=80., rx_min=0.20, rx_max=0.35)\n",
    "    pp.create_transformer(net, b1, b2, \"100 MVA 220/110 kV\")\n",
    "    pp.create_line(net, b2, b3, std_type=\"N2XS(FL)2Y 1x120 RM/35 64/110 kV\" , length_km=15.)\n",
    "    l2 = pp.create_line(net, b3, b4, std_type=\"N2XS(FL)2Y 1x120 RM/35 64/110 kV\" , length_km=12.)\n",
    "    pp.create_line(net, b4, b2, std_type=\"N2XS(FL)2Y 1x120 RM/35 64/110 kV\" , length_km=10.)\n",
    "    pp.create_switch(net, b4, l2, closed=False, et=\"l\")\n",
    "    return net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symmetrische Kurzschlussberechnung\n",
    "\n",
    "### Maximalkurzschlussströme\n",
    "\n",
    "Als erstes berechnen wir die maximalen Kurzschlussströme:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "sc.calc_sc(net, case='max', ip=True, ith=True, branch_results=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für Kanten werden die Ergebnisse als die maximal auftretenden Kurzschlussströme bestimmt, die auftreten, sobald ein Fehler an einem beliebigen Bus im Netz auftritt. Die Ergebnisse sind einerseits verfügbar für Leitungen ...:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.res_line_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... sowie für Transformatoren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.res_trafo_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Minimalkurzschlussströme\n",
    "Ähnlich wie im Falle der Maximalkurzschlussströme können auch die Minimalkurzschlussströme berechnet werden. Allerdings müssen in diesem Fall die Endtemperaturen der Leitungen im Falle eines Fehlers gemäß der Norm angegeben werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "net.line[\"endtemp_degree\"] = 80\n",
    "sc.calc_sc(net, case=\"min\", ith=True, ip=True, branch_results=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entsprechend werden dann auch die Minimalkurzschlusströme in den einzelnen Kantenelementen ausgegeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.res_line_sc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.res_trafo_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Asynchronmaschinen\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asynchonmaschinen können dadurch erzeugt werden, dass man bei der Definierung eines statischen Generators einfach den Typ \"Motor\" angbit. Wichtig hierbei ist, dass man für die Kurzschluss-Impedanz einen R/X-Verhältnis, in pandapower \"rx\" bezeichnet, sowie das Verhältnis zwischen Nominalstrom und Kurzschlussstrom spezifiziert. Dieser Wert ist in pandapower als \"k\" definiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "pp.create_sgen(net, 2, p_mw=0, sn_mva=0.5, k=1.2, rx=7., type=\"motor\")\n",
    "net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Führen wir dieses Mal eine Kurzschlussberechnung durch, so können wir feststellen, dass die Ströme angestiegen sind. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.calc_sc(net, case=\"max\", ith=True, ip=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Synchronmaschinen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Synchronmaschinen sind in pandapower durch das \"gen\"-Element erfasst. Gemäß der Norm sind für die Berechnung des Kurzschlussstromes der Leistungsfaktor (cos$\\varphi$) \"cos_phi\", die Nennspannung \"vn_kv\", die Nennscheinleistung \"sn_mva\" sowie der substransiente Widerstand \"rdss\" und die substransiente Reaktanz \"xdss\" von Nöten, um die Kurzschlussimpedanz zu berechnen: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "pp.create_gen(net, 2, p_mw=0, vm_pu=1.0, cos_phi=0.8, vn_kv=22, sn_mva=5, xdss_pu=0.2, rdss_pu=0.005)\n",
    "net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Führen wir erneut die Kurzschlussberechnung durch, so erhalten wir nun folgendes Ergebnis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.calc_sc(net, case=\"max\", ith=True, ip=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie schon beim Asynchronmotor steigt der Kurzschlussstrom durch den Generator/Motor. Allerdings kann man an der Warnung erkennen, dass nur für weite Entfernungen des Fehlers die Ergebnisse korrekt sind."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vermaschte Netze"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Korrekturfaktoren für aperiodische und thermische Ströme unterscheiden sich zwischen vermaschten und radialen Netzen.\n",
    "\n",
    "In unserem Fall laden wir wieder das Radialnetz zu Beginn, schließen dieses Mal jedoch den Schalter am Ende, um so ein vermaschtes Netz zu erzeugen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "net.switch.closed = True\n",
    "sc.calc_sc(net, ip=True, ith=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zur Validierung vergleichen wir an dieser Stelle nochmals die Ergebnisse mit den Ergebnisse des Radialnetzes. Hierzu öffnen wir den Schalter wieder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.switch.closed = False\n",
    "sc.calc_sc(net, ip=True, ith=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Des Weiteren werfen wir einen Blick auf die Ströme innerhalb der Kanten unter der Annahme, dass das Netz vermascht betrieben wird:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.switch.closed = True\n",
    "sc.calc_sc(net, topology=\"auto\", ip=True, ith=True, branch_results=True)\n",
    "net.res_line_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man kann erkennen, dass die Ströme um einiges kleiner sind als an den Busen. Dies liegt daran, dass sich die Ströme gleichmäßig auf die beiden Halbringe verteilen können."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fault Impedance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Des Weiteren ist es möglich eine Fehlerimpedanz zu definieren ...:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "sc.calc_sc(net, topology=\"radial\", ip=True, ith=True, r_fault_ohm=1., x_fault_ohm=2.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... was die Kurzschlussströme weiter verringert:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Asymmetrische zweiphasige Kurzschlussberechnungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alle Berechnung von oben können auch als zweiphasige Kurzschlussberechnung durchgeführt werden, indem man einfach als \"fault\"-Wert \"2ph\" angibt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "sc.calc_sc(net, fault=\"2ph\", ip=True, ith=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Häufig wird diese Annahme für Minimalkurzschlussstromberechnungen verwendet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ring_network()\n",
    "net.line[\"endtemp_degree\"] = 150\n",
    "sc.calc_sc(net, fault=\"2ph\", case=\"min\", ip=True, ith=True)\n",
    "net.res_bus_sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lessons learned"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Am Ende dieses Tutorials sind Sie in der Lage:\n",
    "- eine dreiphasige Kurzschlussberechnung sowie \n",
    "- eine zweiphasige Kurzschlussberechnung \n",
    "\n",
    "mit pandapower durchzuführen.\n",
    "\n",
    "Sie haben zudem verstanden, welche Auswirkungen:\n",
    "- Maschen\n",
    "- Synchronmaschinen\n",
    "- Asynchronmaschinen\n",
    "\n",
    "auf die Berechnungen haben."
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}