dcopf5barras.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "dcopf5barras.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/opf-ute/scripts/blob/master/dcopf5barras.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fyHK-cAGeFGw",
        "colab_type": "text"
      },
      "source": [
        "Se quiere modelar y resolver el problema de flujo óptimo para el sistema representado por el unifilar de la figura. Se utilizará el modelo DC-OPF.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OSWLje0xJ3G9",
        "colab_type": "code",
        "outputId": "450c4ae4-41a4-4906-d8d6-3bb4a230e6af",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 431
        }
      },
      "source": [
        "from IPython.display import Image\n",
        "from IPython.core.display import HTML \n",
        "\n",
        "\n",
        "Image(url= \"https://drive.google.com/uc?id=1zKqS2zehsZ2IxdM8sdNr7CHbdVfmTxtW\", width=750)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<img src=\"https://drive.google.com/uc?id=1zKqS2zehsZ2IxdM8sdNr7CHbdVfmTxtW\" width=\"750\"/>"
            ],
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fjpF-JIKn5TN",
        "colab_type": "text"
      },
      "source": [
        "El modelo DC-OPF Es dado por las ecuaciones \n",
        "\n",
        "$$\\bf p_L= H\\mathbf \\theta = X^{-1} A \\theta$$\n",
        "\n",
        "para el vector de potencias $\\bf p_L$  por las $M=6$ líneas. En estas ecuaciones $X$ es  una matriz diagonal de dimensiones $M\\times M$ con las reactancias de las líneas en la diagonal, $\\theta$ es el vector de ángulos en las $N=5$ barras, y $A$ es la matriz de incidencia de dimensiones $M\\times  N$.\n",
        "\n",
        "También se tiene para el vector $\\bf p_B$ de potencias  inyectadas en las barras\n",
        "\n",
        "$$\\bf p_B = B\\theta = A^T X^{-1} A \\theta$$\n",
        "\n",
        "Para la red de la figura, con la numeración y los sentidos de las líneas  elegidos según las flechas rojas del esquema mostrado más abajo, se tiene  (A COMPLETAR)\n",
        "\n",
        "$$\n",
        "A=\\begin{bmatrix}\n",
        "    0  & 0 & 0 & -1 & 1 \\\\\n",
        "   -1  & 0 & 0 & 0 & 1 \\\\\n",
        "   1  & 0 & 0 & -1 & 0 \\\\\n",
        "   0  & 0 & -1 &1 & 0 \\\\\n",
        "   1  & -1 & 0 & 0 & 0 \\\\\n",
        "   0  & -1 & 1 & 0 & 0 \\\\\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "$$\n",
        "X=\\begin{bmatrix}\n",
        "    x_{54}  & 0 & 0 & 0 & 0 & 0\\\\\n",
        "   0  & x_{51} & 0 & 0 & 0 & 0\\\\\n",
        "   0  & 0 & x_{14} &  0 & 0 & 0 \\\\\n",
        "   0  & 0 & 0 & x_{43} & 0 & 0 \\\\\n",
        "   0  & 0 & 0 & 0 & x_{12} & 0 \\\\\n",
        "   0  & 0 & 0 & 0 & 0 & x_{32} \\\\\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "con $x_{12}=0.0281$, $x_{23}=0.0108$, $x_{34}=0.0297$, $x_{45}=0.0297$, $x_{14}=0.0304$, $x_{15}=0.0064$ (en p.u.).\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nsR7bIN5yDDl",
        "colab_type": "code",
        "outputId": "4011b6ff-4cf0-4809-f4e2-dfe60b46b9b0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        }
      },
      "source": [
        "Image(url= \"https://drive.google.com/uc?id=1uoDeKu9d-sZhFM3R-2gmdplqNirh0cFf\", width=750)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<img src=\"https://drive.google.com/uc?id=1uoDeKu9d-sZhFM3R-2gmdplqNirh0cFf\" width=\"750\"/>"
            ],
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bjeK0MBeybxb",
        "colab_type": "text"
      },
      "source": [
        "Luego el flujo de carga óptimo para esta red puede obtenerse con el siguiente codigo en CVXPY\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "ZxNP2uruteMQ",
        "colab": {}
      },
      "source": [
        "# Import packages.\n",
        "import cvxpy as cp\n",
        "import numpy as np\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXMhF2-onCjr",
        "colab_type": "code",
        "outputId": "719393e4-e46c-4ce6-8c2c-ac343c3de1c7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 210
        }
      },
      "source": [
        "# Modelo de cinco barras a modificar\n",
        "Sbase = 100 # MVA\n",
        "M=6\n",
        "N=5\n",
        "A=np.array([ [0, 0, 0, -1, 1], [-1, 0, 0, 0, 1], [1, 0, 0, -1, 0], [0, 0, -1, 1, 0], [1, -1, 0, 0, 0], [0, -1, 1, 0, 0] ]) \n",
        "x54 = 0.0297; # pu\n",
        "x51 = 0.0064;\n",
        "x14 = 0.0304;\n",
        "x43 = 0.0297;\n",
        "x12 = 0.0281;\n",
        "x32 = 0.0108;\n",
        "\n",
        "#print(A)\n",
        "\n",
        "X=np.array([ [x54,0,0,0,0,0],[0,x51,0,0,0,0],[0,0,x14,0,0,0],[0,0,0,x43,0,0],[0,0,0,0,x12,0],[0,0,0,0,0,x32] ])\n",
        "#print(X)\n",
        "H=np.linalg.inv(X)@A\n",
        "B= A.transpose()@H\n",
        "#print(H)\n",
        "#print(B)\n",
        "\n",
        "d = np.divide(np.array([0,300,300,400,0]),Sbase)\n",
        "plmax = np.divide(np.array([240,400,400,400,400,400]),Sbase)\n",
        "gmax = np.divide(np.array([40,170,520,200,600]),Sbase)\n",
        "c = np.array([14,15,30,40,10])\n",
        "\n",
        "G2pg=np.array([[1,1,0,0,0],[0,0,0,0,0],[0,0,1,0,0],[0,0,0,1,0],[0,0,0,0,1]])\n",
        "\n",
        "\n",
        "pb = cp.Variable(5) # potencia neta inyectada en las barras = pg-d\n",
        "g = cp.Variable(5) # potencia de cada generador \n",
        "pl = cp.Variable(6) # potencia por las líneas\n",
        "pg = cp.Variable(5) # potencias inyectadas por los generadores en las barras; pg = G2pg*g\n",
        "theta = cp.Variable(5) # ángulos de las barras\n",
        "\n",
        "cost = cp.sum(c*g)\n",
        "\n",
        "constraints = [ theta[0]==0 , G2pg*g == pg , pb==B*theta , pl==H*theta , pb==pg-d , g>=0 , g<=gmax , pl + plmax >= 0 , pl <= plmax ]\n",
        "\n",
        "prob = cp.Problem(cp.Minimize(cost),constraints)\n",
        "prob.solve()\n",
        "\n",
        "potencia_real_generadores = np.multiply(g.value,Sbase)\n",
        "potencia_real_en_barra = np.multiply(pg.value,Sbase)\n",
        "potencia_real_en_linea = np.multiply(pl.value,Sbase)\n",
        "\n",
        "print(\"El costo óptimo es\", prob.value*100)\n",
        "print(\"La generación óptima es, %s\" %potencia_real_generadores)\n",
        "print(\"En cada barra, se genera %s\" %potencia_real_en_barra)\n",
        "print(\"La potencia en cada línea es, %s\" %potencia_real_en_linea)\n",
        "\n",
        "#print(theta.value)\n",
        "#print(H@theta.value-pl.value)\n",
        "#print(B@theta.value-pb.value)\n",
        "#print(pb.value-pg.value+d)\n",
        "#print(prob.status)\n",
        "\n",
        "print(\"El vector multiplicador de Lagrange de la restricción de abastecimiento de la demanda en cada nodo es lambda_n= %s\" %constraints[4].dual_value)\n",
        "print(\"El vector multiplicador de Lagrange de la restricción de límite en las líneas es es lambda_l= %s\" %constraints[3].dual_value)\n",
        "print(\"El vector multiplicador de Lagrange de la restricción de límite de generación es lambda_g= %s\" %constraints[6].dual_value)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El costo óptimo es 17482.418573738698\n",
            "La generación óptima es, [ 40.00234897 170.00234897 276.17425148  31.63069081 482.18952768]\n",
            "En cada barra, se genera [2.10004700e+02 4.93462201e-07 2.76174251e+02 3.16306889e+01\n",
            " 4.82189530e+02]\n",
            "La potencia en cada línea es, [239.98842667 242.20150143 183.4724204   55.09122845 268.73445699\n",
            "  31.26549547]\n",
            "El vector multiplicador de Lagrange de la restricción de abastecimiento de la demanda en cada nodo es lambda_n= [16.95513025 26.39439539 30.01633506 40.01001434  9.96868341]\n",
            "El vector multiplicador de Lagrange de la restricción de límite en las líneas es es lambda_l= [-6.25582286e+01  2.05611863e-02  5.97770732e-03  6.63693981e-03\n",
            "  9.75469475e-03 -9.71199556e-03]\n",
            "El vector multiplicador de Lagrange de la restricción de límite de generación es lambda_g= [ 2.95407528e+00  1.95407528e+00  0.00000000e+00  0.00000000e+00\n",
            " -4.16333634e-16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QIwDqA37sNiF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CyQhXNyPsN-V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nTP0of9J98bg",
        "colab_type": "text"
      },
      "source": [
        "a) Obtener los multiplicadores de Lagrange de las distintas restricciones e interpretarlos.\n",
        "\n",
        "b) Reflexionar sobre qué sucedería si se modificaran los costos de generación y luego correr el problema con nuevos costos.\n",
        "\n",
        "c) Reflexionar sobre qué sucedería si se modificaran los límites de las líneas y luego correr el problema con nuevos costos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SAux8TYWDjkf",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tpJFA8rIDmll",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Escribir código aquí"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}