UNIVERSIDAD CENTROAMERICANA JOS SIMEN CAAS

MODELO DE FLUJO PTIMO DE POTENCIA UTILIZANDO TECNICAS DE OPTIMIZACIN

TRABAJO DE GRADUACIN PREPARADO PARA LA

FACULTAD DE INGENIERA Y ARQUITECTURA

PARA OPTAR AL GRADO DE

INGENIERO ELECTRICISTA

POR:

JULIO CSAR FERNNDEZ GONZLEZ EVER ESMITH FUENTES LPEZ

OCTUBRE 2011 ANTIGUO CUSCATLN, EL SALVADOR, C.A.

RECTOR ANDREU OLIVA DE LA ESPERANZA, S.J.

SECRETARIA GENERAL CELINA PREZ RIVERA

DECANO DE LA FACULTAD DE INGENIERA Y ARQUITECTURA CARLOS GONZALO CAAS GUTIRREZ

COORDINADOR DE LA CARRERA DE INGENIERA ELCTRICA OSCAR ANTONIO VALENCIA MONTERROSA

DIRECTOR DEL TRABAJO RIGOBERTO CONTRERAS VSQUEZ

LECTOR DAVID ADONAY MURCIA ANDRADE

RESUMEN EJECUTIVO Hoy en da, la electricidad es, sin lugar a dudas, el principal motor que impulsa las actividades en cualquier pas y permite su desarrollo. Un sistema elctrico de potencia (SEP), es el conjunto de centrales generadoras, de lneas de transmisin interconectadas mediante centros de transformacin (subestaciones) y redes de distribucin esenciales para el suministro de energa elctrica. Todos los sistemas de potencia deben estar diseados para adaptarse a sus usuarios respetando varios criterios de calidad en el servicio. Estos criterios se refieren a los valores mnimo y mximo de la tensin en los puntos de entrega, la frecuencia de mxima excursin en el valor nominal, etc. El problema de flujo de potencia es calcular la magnitud del voltaje y el ngulo de fase en cada bus de un sistema de potencia en condiciones de estado estable trifsico. Como subproducto de este clculo, se pueden calcular flujos de potencia real y reactiva en equipo como lneas de transmisin y transformadores, as como prdidas de equipo. El punto de partida para un problema de flujo de potencia es un diagrama unifilar del sistema de potencia, a partir del cual se pueden obtener los datos de entrada para las soluciones por computadora. Es de tener en cuenta que no solo importa la solucin de flujos de potencia para la satisfaccin de la demanda, tambin es muy importante el aspecto econmico, por lo cual en este trabajo de graduacin tambin se enfatizara en la resolucin de flujos de potencia ptimo. Su principal objetivo es optimizar las condiciones de operacin en estado estacionario de un sistema elctrico de potencia. Un OPF ajusta las cantidades controlables para optimizar una funcin objetivo mientras satisface un conjunto de restricciones operativas. Una funcin objetivo puede incorporar aspectos econmicos, de seguridad o medioambientales, que se resuelve utilizando tcnicas de optimizacin adecuadas. Las restricciones son leyes fsicas que gobiernan a los generadores, el sistema de transmisin, lmites constructivos de los equipos elctricos y estrategias operativas.

ii

NDICE RESUMEN EJECUTIVO .......................................................................................................................i NDICE DE FIGURAS ..........................................................................................................................v PRLOGO ......................................................................................................................................... vii CAPITULO 1. MODELADO DE LOS ELEMENTOS DEL SISTEMA DE POTENCIA ........................ 1 1.1 Modelado de lneas de transmision .......................................................................................... 1 1.1.1 CIircuitos equivalentes de lneas de transmision ............................................................... 2 1.2 Modelado de los transformadores............................................................................................. 5 1.2.1 Circuitos equivalentes por unidad de transformadores trifsicos balanceados de dos devanados ................................................................................................................................... 6 1.2.2 Transformadores de tres devanados ................................................................................. 7 CAPITULO 2. FLUJOS DE POTENCIA .............................................................................................. 9 2.1 Introduccion ............................................................................................................................... 9 2.2 Metodo de Newton-Raphson .................................................................................................. 10 2.3 El problema de flujo de potencia ............................................................................................. 13 2.4 Solucion de flujos de potencia por el mtodo de Newton-Raphson ....................................... 15 CAPITULO 3. PROGRAMA DE FLUJOS DE POTENCIA ................................................................ 19 3.1 Mosulos de programacin en PYTHON .................................................................................. 20 3.2 Modulo de Carga .................................................................................................................... 21 3.3 Modulo de ybus ...................................................................................................................... 22 3.4 Modulo Newton ....................................................................................................................... 23 3.5 Modulo fpotencia ..................................................................................................................... 25 3.6 Modulo salida .......................................................................................................................... 26 3.7 Ejemplo de flujo de potencia .................................................................................................. 27 3.8 Flujo de potencia en un sistema de catorce nodos................................................................. 32 CAPITULO 4. FLUJO PTIMO DE POTENCIA ............................................................................... 35 4.1 Introduccion ............................................................................................................................. 35 4.2 El problema de flujo optimo de potencia ................................................................................. 36 4.2.1 Formulacion general ........................................................................................................ 36 4.2.2 Variables .......................................................................................................................... 37 4.2.3 Funcion objetivo ............................................................................................................... 38 4.2.4 Restricciones de igualdad ................................................................................................ 39 4.2.5 Restricciones de desigualdad .......................................................................................... 39 4.3 Casos de flujo optimo de potencia (OPF). .............................................................................. 41

iii

4.3.1 OPF de un sistema de dos nodos y modelado AC: sin restricciones de desigualdad. Por mtodo de Newton-Raphson ..................................................................................................... 41 4.3.2 OPF de un sistema multimodal y modelado DC: sin restricciones de desigualdad. Por mtodo de Newton-Raphson ..................................................................................................... 47 CAPITULO 5. CONCLUSIONES Y RECOMENDACIONES ............................................................. 55 5.1 Conclusiones ........................................................................................................................... 55 5.2 Recomendaciones ................................................................................................................... 55 BIBLIOGRAFIA .................................................................................................................................. 57

ANEXOS ANEXO A. PROGRAMA DE FLUJOS DE POTENCIA ANEXO B. PROGRAMA DE FLUJO OPTIMO DEPOTENCIA (OPF) MODELO AC ANEXO C. PROGRAMA DE FLUJO OPTIMO DE POTENCIA (OPF) MODELO DC

iv

INDICE DE FIGURAS Figura 1.1 Modelo lnea corta ............................................................................................................. 1 Figura 1.2 Modelo lnea media ............................................................................................................ 1 Figura 1.3 Modelo lnea larga ............................................................................................................. 2 Figura 1.4 Modelo Figura 1.5 Modelo nominal .............................................................................................................. 2 equivalente......................................................................................................... 4

Figura 1.6 (a) Transformador Ideal Estrella-Estrella ........................................................................... 6 Figura 1.7 Modelos de transformadores ............................................................................................. 7 Figura 2.1 Representacin grafica .................................................................................................... 11 Figura 2.2 Variables del bus ............................................................................................................. 13 Figura 2.3 Bus tpico de un sistema de potencia .............................................................................. 15 Figura 3.1 Diagrama unifilar (impedancias en pu, en 100MVA base) .............................................. 27 Figura 3.2 Diagrama de Flujo de Potencia. ...................................................................................... 31 Figura 3.3 Sistema de 14 Buses ....................................................................................................... 32 Figura 3.4 Interfaz del programa ....................................................................................................... 33 Figura 4.1 Variables de control y de estado ..................................................................................... 37 Figura 4.2 Diagrama unifilar de sistema de dos nodos..................................................................... 41 Figura 4.3 Hessiano sistema de dos nodos ...................................................................................... 44 Figura 4.4 Diagrama Unifilar con flujos en las lneas y costos marginales AC ................................ 46 Figura 4.5 Diagrama Unifilar de sistema de cuatro nodos ................................................................ 47 Figura 4.6 Hessiano sistema de cuatro buses .................................................................................. 51 Figura 4.7 Diagrama Unifilar con flujos en las lneas y sus costos marginales DC .......................... 53

vi

PRLOGO El objetivo principal de este trabajo es el disear un programa que sea capaz de solucionar el problema de flujo de carga para cualquier sistema elctrico de potencia que se desee analizar. As como implementar un programa capaz de resolver problemas de flujo ptimo de potencia. En base a esto se tiene que tener en cuenta que: Para la aplicacin de cualquier mtodo para la solucin de un flujo de carga, requiere un conocimiento detallado de los elementos que componen un sistema de potencia. En este sentido el capitulo 1 presenta una revisin a los componentes o elementos que se tomaran en cuenta para el anlisis del flujo de potencia, presentando como se modela cada uno de estos componentes. En el capitulo 2, se presenta el mtodo de solucin para el flujo de carga, detallando el mtodo de una forma general y grafica para la comprensin de este. Se plantea tambin el problema del flujo de potencia el cual es calcular la magnitud del voltaje y el ngulo de fase en cada uno de los buses del sistema. Al final del capitulo se presenta la solucin del flujo de potencia por el mtodo de Newton-Raphson. A lo largo del capitulo 3 se elabora el programa para la solucin del flujo de potencia, as como los mdulos que conforman este programa detallando cada uno de estos. Tambin se presenta un problema sencillo de un sistema de 3 nodos al cual se le aplica el programa elaborado para la solucin de este. Adems se resuelve un sistema de potencia compuesto por 14 nodos presentando sus resultados y comparndolos con otro programa. En el capitulo 4 y ultimo, se define lo que es un flujo optimo de potencia, as como el problema de flujo optimo de potencia. Se presenta su formulacin general, variables y sus restricciones, por ltimo se resuelve 2 sistemas de potencia, uno modelando AC y el otro modelado DC el cual se proceder a realizar un programa de forma general para el modelo DC.

vii

viii

CAPITULO 1. MODELADO DE LOS ELEMENTOS DEL SISTEMA DE POTENCIA Se detallaran los diferentes elementos del sistema de potencia que se tomaran en cuenta para el anlisis del flujo de potencia, por lo cual se explicaran los distintos modelos de cada uno de estos elementos. 1.1 Modelado de lneas de transmision Las lneas de transmisin pueden clasificarse en: cortas medianas y largas, y en base a eso se obtiene un modelo matemtico que debe ser tomado en cuenta al momento de la simulacin de flujos de potencia. Lneas Cortas: El circuito de la figura 1.1 representa una lnea de transmisin corta, por lo comn aplicadas a lneas con menos de 80 km de largo y a 60 Hz. Adems para este caso la admitancia en derivacin se desprecia.

Figura 1.1 Modelo lnea corta Lneas Medianas: Para las lneas de longitud media, que por lo general varan de 80 a 250 km, a 60 Hz, es frecuente concentrar la capacitancia total en derivacin y situar la mitad en cada extremo de la lnea. En la figura 1.2 se muestra el circuito equivalente para este tipo de lnea.

Figura 1.2 Modelo lnea media Lneas Largas: Las lneas a 60 Hz, con una longitud mayor a 240 km, son consideradas como largas. Para este tipo de lnea debe considerarse el hecho de que los parmetros de la lnea no estn agrupados sino distribuidos uniformemente a lo largo de la lnea. El circuito de la figura 1.3 muestra una seccin de lnea.

Figura 1.3 Modelo lnea larga 1.1.1 CIircuitos equivalentes de lneas de transmision NOMINAL de una lnea de transmisin

CIRCUITO

A continuacin se presenta el modelaje del circuito equivalente

Figura 1.4 Modelo

nominal

Por KCL la corriente en la impedancia en serie es designado por la

es:
Ec.1.1

La corriente en el extremo receptor es: Ec.1.2 Por LVK el voltaje en el extremo transmisor es: Ec.1.3 Donde: Por tanto, si es la tensin en el extremo emisor y Ec.1.4 la tensin en el extremo receptor, se tiene

las siguientes relaciones: Ec .1.5 La corriente en el extremo del transmisor ser:

Ec.1.6 Sustituyendo en se tiene: Ec.1.7 Donde: Ec.1.8 Ec.1.9 Ec.1.10 A las constantes ABCD se les llama constantes generalizadas de circuito de la lnea de transmisin. En general, son nmeros complejos, A y D son adimensionales e iguales entre s, si la lnea es la misma cuando se ve desde cada terminal. Las dimensiones de B y C son los ohmios y los mhos o siemens, respectivamente. Las constantes se aplican a cualquier red lineal, pasiva y con cuatro terminales en dos lados, y cada uno tiene un par de ellas. A tal circuito se le conoce como red de dos puertos. Se puede dar un significado fsico a las constantes, as: Cuando , es cero se observa que A es la relacin sin carga.

La constante B es la relacin

cuando el extremo receptor esta en corto circuito.

La constante A es til en el clculo de la regulacin. Si es el voltaje en el extremo receptor a plena carga para un voltaje en el extremo generador la ecuacin ser: Por ciento de regulacin:

Ec.1.11

CIRCUITO

EQUIVALENTE equivalente. Es idntico en estructura y

El circuito que se muestra en la figura 1.5 se llama circuito al circuito nominal excepto en que se usan y

en lugar de Z y Y. El objetivo es determinar

tales que el circuito

equivalente tenga los mismos parmetros ABCD que los de la lnea equivalente, el cual tiene la misma estructura que

distribuida. Los parmetros ABCD del circuito el circuito nominal, son:

Ec.1.12 Ec.1.13 Ec.1.14

Figura 1.5 Modelo

equivalente Ec.1.15

Ec.1.16

En donde se ha reemplazado Z y Y con Zy Y al igualar las ecuaciones

con Ec.1.13 Ec.1.17

Al escribir de nuevo la ecuacin (1.17) en trminos de la impedancia

del circuito

nominal,

Ec.1.18 En donde por unidad De modo similar, igualando la ecuacin (1.1.12) con por unidad, Ec.1.19

Ec.1.20 Usando la ecuacin (1.1.17) y la identidad , la ecuacin (1.1.20) queda Ec.1.21 Al escribir de nuevo la ecuacin (1.1.21) en trminos de la admitancia del circuito nominal,

Ec.1.22 En donde por unidad Ec.1.23

Las ecuaciones (1.1.19) y (1.1.23) dan los factores de correccin el circuito nominal, en Z y Y para el circuito equivalente.

para convertir Z y Y, para

En el caso de estudio se utiliza un modelo PI equivalente para la lnea, el cual, a travs de sus elementos, representa los efectos fsicos producidos en la lnea de transmisin. Con este modelo se establece la relacin entre las corrientes y tensiones a travs de la matriz compleja de admitancias. Las magnitudes de los elementos del modelo PI, son utilizados por el OPF (Flujo Optimo de Potencia) para calcular la matriz de admitancia nodal compleja del sistema completo. sta participa directamente en las ecuaciones de flujo de potencia y determina las prdidas en las lneas de transmisin.

1.2 Modelado de los transformadores Los transformadores, son elementos que tienen la capacidad de transformar tensiones alternas. Adems, pueden cambiar su razn de transformacin a travs de los denominados taps, que dependiendo del tipo de transformador, pueden ser manipulados de distintas formas por los operadores de la red. El modelo de transformador, incluye adems el efecto de transformacin de tensin debida al tap. Los transformadores poseen la capacidad de cambiar su razn de transformacin a travs de los taps, lo cual fue modelado como variable de control en el OPF.

Al igual que en el caso de las lneas de transmisin, se establece la relacin entre las corrientes y tensiones travs de la matriz de admitancias.

1.2.1

Circuitos equivalentes por unidad de transformadores trifsicos balanceados de dos devanados

La figura 1.6(a) es una representacin de un transformador ideal estrella-estrella, conectado a tierra a travs de las impedancias y del neutro.

En la figura 1.6 (b) se muestra el circuito equivalente por unidad de este transformador ideal para la operacin trifsica balanceada. Por convencin, se adoptaran las dos reglas siguientes para seleccionar las cantidades bases: 1. Se selecciona una comn tanto para la terminal H como para la X. ,

2. Se selecciona la relacin de transformacin respecto a las tensiones bases,

para que sea igual a la relacin de las tensiones nominales lnea a lnea, .

Figura 1.6 (a) Transformador Ideal Estrella-Estrella

Figura 1.6 (b) Circuito equivalente por unidad Cuando se aplican corrientes trifsicas balanceadas al transformador, las corrientes en el neutro son igual a cero y no se tienen cadas de tensin a travs de las impedancias de neutro.

1.2.2 Transformadores de tres devanados En la figura 1.7 (a) se muestra un transformador monofsico bsico de tres devanados. Se puede extender con facilidad las relaciones del transformador ideal de dos devanados, con el fin de obtener las relaciones correspondientes para un transformador ideal de tres devanados. En unidades reales, estas relaciones son: Ec.1.24 Ec.1.25 En donde entra por la terminal con punto, e salen por las terminales con punto, y , y

tienen sus polaridades

en las terminales con punto. Por unidad las ecuaciones quedan as: Ec.1.26 Ec.1.27

En donde se selecciona una

para los tres devanados, y las bases de tensin se seleccionan

en proporcin a las tensiones nominales de los devanados. El circuito equivalente por unidad mostrado en la figura 1.7 (b) satisface estas dos relaciones por unidad. En el circuito del transformador practico de tres devanados que se muestra en la figura 1.7 (c), tambin se incluye la impedancia externa en serie y las ramas de admitancia en derivacin.

Figura 1.7 Modelos de transformadores Las ramas de admitancia en derivacin, un resistor de prdidas en el ncleo en paralelo con un inductor magnetizado, se puede evaluar a partir de una prueba de circuito abierto. Asimismo, cuando un devanado se deja abierto, el transformador de tres devanados se comporta como uno de dos devanados y se pueden aplicar las pruebas estndar de cortocircuito para evaluar las impedancias de dispersin por unidad, las cuales se definen como sigue:

= impedancia de dispersin por unidad medida del devanado 1, con el devanado 2 en cortocircuito y el 3 abierto. = impedancia de dispersin por unidad medida del devanado 1, con el devanado 3 en cortocircuito y el 2 abierto. = impedancia de dispersin por unidad medida del devanado 2, con el devanado 3 en cortocircuito y el 1 abierto. De la figura 1.6 (c), con el devanado 2 en cortocircuito y el 3 abierto, la impedancia de dispersin medida del devanado 1 es, despreciando la rama de admitancia en derivacin, Ec.1.28 De igual modo, Ec.1.29 y Ec.1.30 Resolviendo las ecuaciones anteriores, Ec.1.31 Ec.1.32 Ec.1.33 Se puede usar las ecuaciones antes mencionadas para evaluar las impedancias en serie por unidad, , y , del circuito equivalente del transformador de tres devanados, a partir de las , y , las cuales, a su vez, se determinan a partir de

impedancias de dispersin por unidad pruebas de cortocircuito.

Note que cada uno de los devanados en un transformador de tres de ellos puede tener una capacidad nominal diferente en KVA. Si las impedancias de dispersin de las pruebas de cortocircuito se expresan por unidad, con base en las capacidades nominales de los devanados, primero deben convertirse por unidad respecto a una ecuaciones. comn, antes de que se usen en las

CAPITULO 2. FLUJOS DE POTENCIA 2.1 Introduccion Con los antecedentes del capitulo anterior, ya se tienen las bases para estudiar las caractersticas de operacin de un sistema elctrico de potencia. El rgimen permanente simtrico es, de hecho, el modo ms importante de operacin de un sistema elctrico de potencia. Enseguida se relacionan, en orden jerrquico, tres importantes problemas que se encuentra en este modo de operacin: Problema de flujo carga Problema de programacin optima de carga Problema de control de sistemas Este capitulo se dedica al problema de flujo de carga. El estudio de flujo de carga, en la jerga de sistemas elctricos de potencia, es la solucin de rgimen permanente de la red del sistema. La principal informacin que se obtiene de este estudio incluye las magnitudes y los ngulos de fase de voltajes de buses, potencia reactiva en los buses del generador, flujo real y reactivo de potencias en las lneas de transmisin y otras variables que se especifiquen. Esta informacin es esencial para el monitoreo continuo del estado actual del sistema y para analizar la eficacia de plantas alternas para futuras expansiones del sistema para satisfacer una demanda creciente de carga. La red contiene cientos de nodos y ramas con una impedancia especificada en por unidad sobre una base imponible comn MVA. Las ecuaciones de red pueden ser formuladas de forma sistemtica en una variedad de formas. Sin embargo, el mtodo de voltaje de nodos, que es la forma ms adecuada para muchos anlisis del sistema de potencia, es comnmente usado. La formulacin de las ecuaciones de red en la admitancia nodal forma resultados de ecuaciones algebraicas lineales simultneas complejas en trminos de corrientes de nodo. Cuando las corrientes de nodo se especifican, el conjunto de ecuaciones lineales pueden ser resueltas por los voltajes de nodo. Sin embargo, en un sistema de potencia, las potencias son conocidas y no las corrientes. Por lo tanto, las ecuaciones resultantes en trminos de potencia, son conocidas como las ecuaciones de flujo de potencia, se convierten en ecuaciones no lineales y deben ser resueltas por tcnicas iterativas. . Los estudios de flujo de potencia, comnmente conocido como flujo de carga, son necesarios para el funcionamiento, la programacin econmica y el intercambio de energa entre empresas de servicios pblicos. Adems, el anlisis de flujo de potencia se requiere para muchos otros anlisis, tales como la estabilidad transitoria y los estudios de contingencia.

2.2 Metodo de Newton-Raphson El mtodo de Newton-Raphson es un mtodo para resolver ecuaciones algebraicas no lineales. Funciona ms rpidamente y es seguro que converge en la mayor parte de los casos al compararlo con otros mtodos. Es sin duda el mtodo prctico para la solucin de flujo de carga en redes elctricas de potencia grandes. Antes de explicar como se aplica el mtodo NR para resolver el problema de flujo de carga, es til revisar el mtodo en su forma general. Considere un sistema de n ecuaciones algebraicas no lineales ; Suponga que los valores iniciales de las incgnitas son Sean Ec.2.1 las

correcciones que, al hacerse a la primera suposicin, dan la solucin real. Por lo tanto, Ec.2.2 Al desarrollar estas ecuaciones en serie de Taylor con la suposicin inicial, se tiene

Donde

son las derivadas de

con respecto a

, evaluadas en

Si los trminos de orden superior se desprecian, puede escribirse en forma matricial

Ec.2.3

O en forma de matriz vectorial Ec.2.4 se conoce como matriz jacobiana (que se obtiene al diferenciar el vector funcin respecto a y se evala en ). La ecuacin anterior se puede escribir como: Ec.2.5 con

10

Se puede obtener valores aproximados de correccin

. Como estos constituyen un sistema de

ecuaciones algebraicas lineales se pueden resolver de manera eficiente mediante triangulacin y resustitucion. Los valores actualizados de son entonces

O, en general, para la iteracin

, Ec.2.6

Las iteraciones se continan hasta que la ecuacin (2.1) se satisfaga para cualquier exactitud deseada, es decir, (un valor especificado); Ec.2.7

REPRESENTACION GRAFICA Este mtodo, el cual es un mtodo iterativo, es uno de los ms usados y efectivos. El mtodo de Newton-Raphson no trabaja sobre un intervalo sino que basa su frmula en un proceso iterativo. Supongamos una funcin a la que se desea calcular su raz

Figura 2.1 Representacin grafica Evaluando un valor cercano a la raz en la funcin y trazando una recta tangente en el punto que es mucho ms cercano a la raz que

se obtiene un nuevo valor Para encontrar el valor de

, se tomara la ecuacin de la recta. Ec.2.8

11

Se supone que

sea igual a 0 para que

sea una raz de Ec.2.9

Pero en el punto

la pendiente m puede tomarse como

por ser la mejor aproximacin

a la pendiente en dicho punto. Ec.2.10 Ec.2.11 Y despejamos Ec.2.10 Si buscamos una mejor aproximacin a la raz utilizando este nuevo valor Ec.2.11 Si nuevamente se busca otra aproximacin que es cada vez ms cercana a la raz, Ec.2.12 Entonces podemos generalizar la ecuacin de la siguiente manera, Ec.2.13

Note que el mtodo de Newton-Raphson no trabaja con intervalos donde nos asegure que encontraremos la raz, y de hecho no tenemos ninguna garanta de que nos aproximaremos a dicha raz. Desde luego, existen ejemplos donde este mtodo no converge a la raz, en cuyo caso se dice que el mtodo diverge. Sin embargo, en los casos donde si converge a la raz lo hace con una rapidez impresionante, por lo cual es uno de los mtodos preferidos por excelencia. Tambin observe que en el caso de que , el mtodo no se puede aplicar. De hecho,

vemos geomtricamente que esto significa que la recta tangente es horizontal y por lo tanto no intercepta al eje raz de . en ningn punto, a menos que coincida con ste, en cuyo caso mismo es una

12

2.3 El problema de flujo de potencia El problema de flujo de potencia es calcular la magnitud del voltaje y el ngulo de fase en cada bus de un sistema de potencia en condiciones de estado estable trifsico. Como subproducto de este clculo, se pueden calcular flujos de potencia rea y reactiva en equipo como lneas de transmisin y transformadores, as como prdidas de equipo. El punto de partida para un problema de flujo de potencia es un diagrama unifilar del sistema de potencia, a partir del cual se pueden obtener los datos de entrada para soluciones por computadora. Los datos de entrada consisten en datos de buses, datos de las lneas de transmisin y de los transformadores. Como se muestra en la figura 2.2, las cuatro variables siguientes estn asociadas con cada bus k: magnitud de voltaje bus. , ngulo de fase , potencia neta real y potencia activa abastecida al

Bus k

Carga L

Figura 2.2 Variables del bus En cada bus, dos de las variables se especifican como datos de entrada y las otras dos son incgnitas que se calcularan mediante el programa de flujo de potencia. Por conveniencia, la potencia entregada al bus en la figura 2.2 se separa en generacin y carga. Es decir,

Cada bus

se clasifica en uno de los tres tipos siguientes:

Bus compensador: Solo hay un bus compensador, que por conveniencia en este trabajo se le asigna el numero 1. El bus compensador es una referencia para la cual , por lo

13

comn 1.0 y .

por unidad, es un dato de entrada. El programa de flujo de potencia calcula

Sus instrucciones, por as decirlo, es hacer lo que sea necesario para mantener el equilibrio de potencia real en el sistema, esto significa mantener el ngulo de tensin constante. Bus de carga: y son datos de entrada. El programa de flujo de potencia calcula y

. La mayor parte de los buses en un programa normal de flujo de potencia son de carga. Bus de voltaje controlado: calcula y y son datos de entrada. El programa de flujo de potencia

. Como ejemplos estn los buses a los que estn conectados los

generadores, capacitores en derivacin desconectables, o sistemas compensadores estticos de VARs. Los lmites de VARs mximo y mnimo y que este tipo

puede suministrar son tambin datos de entrada. Otro ejemplo es un bus al que esta conectado un transformador con cambiador de derivaciones; el programa de flujo de potencia calcula entonces la posicin del cambiador. Observe que cuando el bus k es un bus de carga sin ninguna generacin, es

negativo; es decir que la potencia real suministrada al bus k en la figura 2.2 es negativa. Si la carga es inductiva, es negativa. equivalente, que se muestra en

Las lneas de transmisin estn representadas por el circuito la figura 1.5.

Los datos de entrada para cada lnea de transmisin son la impedancia derivacin del circuito

y la admitancia de

equivalente por unidad, los dos buses a los que esta conectada la

lnea y la capacidad mxima en MVA. De manera similar, los datos de entrada para cada transformador son las impedancias de derivacin por unidad excitacin por unidad , la admitancia de la rama de

, los buses a los que estn conectados los devanados y las

capacidades mximas en MVA. La matriz de admitancia de se puede construir a partir de los datos de entrada de son:

transformadores y lneas. Los elementos de Elementos de la diagonal: terminan en el nodo. Elementos fuera de la diagonal:

es igual a la suma algebraica de todas las admitancias que

Es igual al negativo de la suma de todas las admitancias

conectadas directamente entre estos dos nodos. Adems,

14

2.4 Solucion de flujos de potencia por el mtodo de Newton-Raphson Debido a su convergencia cuadrtica, el mtodo de Newton es matemticamente superior al mtodo de Gauss-Seidel y es menos propenso a la divergencia con problemas mal condicionados. El nmero de iteraciones necesarias para obtener una solucin es independiente del tamao del sistema, pero ms evaluaciones funcionales se requieren en cada iteracin. Dado que en el problema de flujo de potencia, la potencia real y la magnitud del voltaje se especifican para los buses controlados por voltaje, la ecuacin de flujo de potencia se formula en forma polar. Para el bus tpico del sistema de alimentacin que muestra en la Figura 2.3, la corriente que entra al bus viene dada por. Ec.2.14

Figura 2.3 Bus tpico de un sistema de potencia

Esta ecuacin puede ser reescrita en trminos de la matriz de admitancia de bus como Ec.2.15 En la ecuacin anterior, j incluye bus i. Expresando esta ecuacin en forma polar, tenemos Ec.2.16 La potencia compleja en el bus i es Ec.2.17 Sustituyendo la ecuacin (2.13) en (2.14)

Ec.2.18 15

Separando la parte real e imaginaria Ec.2.19 Ec.2.20 Las ecuaciones (2.19) y (2.20) constituyen un grupo de ecuaciones algebraicas no lineales en trminos de variables independientes, la magnitud del voltaje en por unidad, y el ngulo de fase en radianes. Tenemos dos ecuaciones por cada bus de carga, dadas por (2.19) y (2.20), y una ecuacin por cada bus de controlador de voltaje dada por (2.19). Expandiendo (2.19) y (2.20) en serie de Taylor sobre la estimacin inicial y dejando de lado los trminos de orden superior da como resultado el siguiente conjunto de ecuaciones lineales.

En el conjunto de ecuaciones anterior, el bus numero 1 es asumido como el bus slack. La matriz Jacobiana da la relacin entre cambios pequeos en el ngulo del voltaje voltaje con los cambios pequeos en la potencia real y reactiva y la magnitud del y . Los

elementos de la matriz jacobiana son las derivadas parciales de (2.19) y (2.20), evaluados en y . En una forma corta esta se puede escribir como

Ec.2.21
Para el bus controlado por voltaje, la magnitud del voltaje es conocida. Por lo tantos si m buses de el sistema son controlados por voltaje, m ecuaciones involucran y y las columnas restricciones

correspondientes en la matriz Jacobiana sern eliminada. Por consiguiente hay de potencia real y

restricciones de potencia reactiva, y la matriz Jacobiana es de orden . El es de orden , y el . El es de orden es de orden .

. El

es de orden

La diagonal y los elementos fuera de la diagonal de

son

16

Ec.2.22 Ec.2.23 La diagonal y los elementos fuera de la diagonal de son Ec.2.24 Ec.2.25 La diagonal y los elementos fuera de la diagonal de son Ec.2.26 Ec.2.27 La diagonal y los elementos fuera de la diagonal de son Ec.2.28 Ec.2.29 Los trminos y son la diferencia entre el valor previsto y calculado, conocida como

residuo de potencia, dada por Ec.2.30 Ec.2.31 La nueva estimacin para el voltaje de bus son Ec.2.32 Ec.2.33 El procedimiento para la solucin de flujos de potencia por el mtodo de Newton-Raphson es el siguiente: 1. Para el bus de carga, donde y son especificados, la magnitud del voltaje y el y . Para

ngulo de fase son valores iguales al del bus slack, o 1.0, los buses regulado por voltaje, donde igual al ngulo de fase del bus slack, o 0, 2. Para el bus de carga, y y

son especificados, el ngulo de fase es . y son

son calculados con (2.19) y (2.20) y

calculados con (2.30) y (2.31) respectivamente. 3. Para el bus controlado por voltaje, 4. Los elementos de la matriz Jacobiana y son calculados con (2.19) y (2.30). y son calculados con (2.22)-(2.29).

5. La nueva magnitud de voltaje y ngulo de fase son calculados por (2.32) y (2.33). 6. El proceso se continua hasta que los residuos especificada y son menores que la precisin

17

Ec.2.34 Ec.2.35

18

CAPITULO 3. PROGRAMA DE FLUJOS DE POTENCIA Para tener una optima operacin de los sistemas de potencia en condiciones normales balanceadas de estado estable trifsico, se requiere lo siguiente: La generacin abastece la demanda (carga) ms las perdidas. Las magnitudes de voltaje en las barras permanecen cercanas a sus valores nominales Los generadores operan dentro de limites especificados de potencia real y reactiva Las lneas de transmisin y los transformadores no estn sobrecargados. El programa de computadora de flujos de potencia (conocidos como flujos de carga) es la herramienta bsica para investigar estos requerimientos. Con este programa se calcula la magnitud del voltaje y el ngulo en cada barra o bus en un sistema de potencia en condiciones balanceadas en estado trifsico. Tambin permite calcular los flujos de potencia real y reactiva para los equipos que interconectan las barras, as como las perdidas en los equipos. En este capitulo se desarrollara el modelo de flujo de carga, el mtodo que se utilizara para la solucin de los flujos de carga ser el de Newton-Raphson. Se realizara todo el cdigo de programacin en lenguaje Python, el programa se desarrollara de una forma modular para una mayor comprensin, y se explicara en que consiste cada uno de estos mdulos.

19

3.1 Mdulos de programacin en PYTHON El programa de flujo de potencia desarrollado consta de los siguientes mdulos: 1. Modulo de Carga de datos. Es el encargado de la lectura de datos. 2. Modulo Ybus. Se formara la matriz de admitancia. 3. Modulo Newton. Resuelve el problema de flujo de carga por el mtodo de NewtonRaphson. 4. Modulo fpotencia. Calcula los flujos de potencia activa y reactiva. 5. Modulo Salida. Muestra los resultados obtenidos. Se cuenta con una interfaz para la introduccin de datos de manera flexible. La interfaz se ha realizado en Notepad en donde primeramente se detalla los MVA base que se utilizaran para el anlisis de algn sistema en particular. A continuacin se encuentra lo que son los datos de los buses en donde se introducen los datos como el nombre del bus, el tipo de bus (en este se coloca si el bus es de tipo PV, PQ o Bus de referencia con el cual el programa desarrollado entiende la siguiente nomenclatura: se colocara 2 si el bus es de tipo PV, se colocara 0 si es de tipo PQ, y 1 si es el Bus de referencia), la magnitud de voltaje del bus, el ngulo en radianes, la demanda (carga) en MW, la demanda (carga) en MVAR, los MW del generador conectado al bus, los MVAR del generador conectado al bus. En el siguiente bloque de la interfaz se encuentran la interconexin de los buses y los parmetros de la lnea que los interconecta siendo dichos parmetros resistencia (R), reactancia (X) y susceptancia (B). Despus se encuentra el bloque en donde se especifica la interconexin de las lneas en paralelo del sistema con sus parmetros respectivos. En el bloque siguiente se encuentran los datos de transformadores de dos devanados en el cual se introducen los parmetros de resistencia, reactancias y susceptancia. Y por ultimo se encuentra el bloque donde introduciremos los datos de transformadores de tres devanados, sus resistencias del primario al secundario, del primario al terciario, del secundario al terciario, y as mismo sus reactancias y susceptancias.

A continuacin se presenta un ejemplo de la interfaz del programa elaborado.

20

3.2 Modulo de Carga Este genera la carga de datos desde Notepad hasta Python, generando las matrices necesarias de datos para poder manipularlas como tal. A continuacin se presenta la seccin del programa elaborado que lee el archivo de datos, en el mismo hay comentarios explicativos.

21

3.3 Modulo de ybus Este modulo o funcin genera la matriz de admitancias conocida en el anlisis de sistemas de potencia como YBUS. El cdigo de este modulo se encuentra a continuacin

22

3.4 Modulo Newton Este modulo tiene por funcin hacer todas las iteraciones pertinentes en cuanto a la bsqueda de la solucin del sistema de potencia, considerando las ecuaciones necesarias en el anlisis AC de los sistemas de potencia, empezaremos por describir brevemente las etapas de este modulo. La primera etapa del diseo de este modulo consta del calculo de potencia con los parmetros de iniciacin del sistema, en otras palabras, las potencias tanto la activa como la reactiva se calculan con los voltajes y ngulos inciales introducidos por el usuario.

La segunda de la etapas importantes de este modulo es la etapa de formacin de la matriz Jacobiana la cual se divide en cuatro submatrices llamadas J1, J2, J3 y J4

23

Despus de formadas las submatrices hay que formar la matriz Jacobiana completa

Cuando la matriz Jacobiana ya esta completa para la primera iteracin y las siguientes que se formaran se invierte y multiplica por los deltas que para el caso de la primera iteracin los deltas corresponden a los valores inicialmente calculados en la primera etapa de este modulo. Luego se despejan los nuevos valores calculados para Voltaje y ngulos y se procede nuevamente desde la primera etapa hasta lograr la convergencia cuando los deltas de potencia son comparados que el nivel de tolerancia establecido para nuestro caso de 0.001.

24

3.5 Modulo fpotencia Como subproducto de calculo iterativo de voltajes y ngulos utilizando el mtodo de Newton se derivan los clculos de flujos de potencia activa y reactiva en cada una de las lneas y elementos que existen en el sistema de potencia en anlisis, y para ello el modulo fpotencia calcula estos flujos de potencia actica y reactiva a partir de los valores proporcionados por el mtodo de Newton. Una de las aclaraciones que cabe retomar es que cuando el sistema lleva elementos como transformadores el calculo de los flujos en cada elemento del sistema se vuelve mas complejo, por lo que cabe sealar que debido a esta consideracin se tomo la decisin de calcular primero las corrientes nodales y en base a ellas obtener las potencias puesto que el voltaje de nodo se conoce. As se calculo la potencia compleja S separando sus componentes real e imaginario, a los que se les denomina potencia activa y potencia reactiva respectivamente.

25

3.6 Modulo salida El ultimo de los mdulos es el modulo que genera el reporte de resultados. Se crea un archivo de block de notas los resultados de magnitud de voltaje y ngulos en grados de cada uno de los buses del sistema analizado y a continuacin el flujo de potencia real y reactiva de cada unos de los elementos que conforman el sistema de potencia.

Con el objeto de demostrar la aplicacin del programa diseado se presenta a continuacin ejemplos a distintos sistemas de potencia.

26

3.7 Ejemplo de flujo de potencia La solucin de flujo de potencia por el mtodo de Newton-Raphson es demostrado en el siguiente ejemplo:

Slack Bus

Figura 3.1 Diagrama unifilar (impedancias en pu, en 100MVA base) La Figura 3.1 muestra el diagrama unifilar de un sistema de potencia sencillo de tres buses, con generadores en los buses 1 y 3. La magnitud de voltaje del bus 1 es ajustada a 10.5 p.u. La magnitud de voltaje en el bus 3 es fijada en 1.04 p.u. con una potencia real de generacin de 200 MW. Una carga que consiste de 400 MW y 250 Mvar conectadas al bus 2. Las impedancias de lneas mostradas se encuentran en por unidad tomando como base 100 MVA, y la susceptancia de la lnea de carga se desprecian. Obtener la solucin de flujo de potencia por el mtodo de Newton-Raphson incluyendo flujos y perdidas en las lneas.

Solucin Las impedancias de lnea se convierten en admitancias:

Esto da lugar a la matriz de admitancia de bus

Convirtiendo la matriz de admitancia de bus a forma polar con sus ngulos en radianes

De (2.16) y (2.17), la expresin de la potencia real en el bus 2 y 3 y la potencia reactiva en el bus 2 son

27

Los elementos de la matriz Jacobiana son obtenidas por las derivadas parciales con respecto a y .

La carga y generacin expresada en por unidad son

El voltaje del bus slack es Iniciando con una estimacin inicial de son calculados con (2.27) y (2.28)

pu, y en el bus 3 la magnitud del voltaje es , ,y

pu.

, los residuos de potencia

Evaluando los elementos de la matriz Jacobiana con la estimacin inicial, el conjunto de ecuaciones lineales en la primera iteracin se convierte en

Obteniendo la solucin de la ecuacin de la matriz anterior, los nuevos voltajes de bus en la primera iteracin son

28

El ngulo del voltaje de fase es en radianes. Para la segunda iteracin, tenemos

Para la tercera iteracin, tenemos

La solucin converge en 3 iteraciones con un desfasamiento mximo de potencia de y

con

. De (2.17) y (2.18), las expresiones de la potencia

reactiva en el bus 3 y las potencias real y reactiva en el bus slack son

Tras la substitucin, tenemos

29

Para encontrar los flujos en las lneas, primero se encuentran las corrientes de lnea

Los flujos en las lneas son

Y las perdidas en las lneas son

30

El diagrama de flujo de potencia es mostrado en la figura 3.2, indicando la direccin del flujo tanto de potencia activa como reactiva. 179.362 170.968 400

218.423

118.734 39.061 140.852 22.118 38.878 238.878

101.947 229.032

250 21.569 167.746 148.053

200

146.177

Flujo en MW Flujo en Mvar

Figura 3.2 Diagrama de Flujo de Potencia.

Comparando los resultados anteriores con los obtenidos con el programa desarrollado en Python, los resultados son exactamente los mismos.

A continuacin se presenta el reporte de salida que genera el programa.

31

3.8 Flujo de potencia en un sistema de catorce nodos El programa realizado en Python se aplicara a un sistema de potencia de catorce nodos figura 3.3, comparando respuestas con los resultados obtenidos en PSAT.

Figura 3.3 Sistema de 14 Buses

El sistema esta compuesto por catorce buses, lneas en paralelo, transformadores de dos y tres devanados, generadores y cargas.

32

Primeramente se introducen los datos a nuestra interfaz como se muestra en la figura 3.4

Figura 3.4 Interfaz del programa

33

Luego corremos el programa y los resultados son los siguientes:

En los perfiles de voltaje de la simulacin se puede apreciar que para los buses de carga los voltajes de dichos buses son inferiores a los voltajes nominales de cada uno de ellos, esto es debido al efecto que las cargas producen por la gran demanda de potencia en conjunto con las perdidas de las lneas de transmisin, lo contrario para los buses de generacin o compensadores, el voltaje se mantiene en su nominal debido a la inyeccin de potencia y a que en estos las perdidas de las lneas son compensadas por la generacin propia de cada bus. Los resultados obtenidos se compararon con los resultados que se obtienen de PSAT, teniendo resultados similares con ambos programas.

34

CAPITULO 4. FLUJO PTIMO DE POTENCIA 4.1 Introduccion El Flujo Optimo de Potencia (OPF) por sus siglas en ingles, es un problema que fue definido en los principios del ao 1960 como una extensin del problema de despacho econmico de carga convencional, que se utiliza para la determinacin ptima de las variables de control en un SEP, considerando variadas restricciones. OPF, en su formulacin general, es un problema de optimizacin con funcin objetivo y restricciones no lineales, que representa la operacin en estado estacionario del sistema elctrico. Dos objetivos bsicos se deben cumplir en la operacin de un sistema elctrico de potencia: i) Asegurar una operacin segura, y ii) Encontrar un punto de operacin econmico. La operacin econmica significa reducir los costos por la utilizacin de la energa elctrica, esto incluye los costos de produccin, transporte y consumo. A pesar de que los costos de transporte de la energa elctrica hacia los centros de consumo, podra representar un pequeo porcentaje de los gastos totales de operacin. La aplicacin de tcnicas de optimizacin a los problemas de planificacin y operacin de SEP (Sistema Elctrico de Potencia), como lo es OPF, es una activa rea de investigacin. De esta forma, OPF puede ser visto como un trmino genrico que describe una amplia gama de clases de problemas en los cuales se busca optimizar una funcin objetivo especfico, sujeto a restricciones que representan los balances de potencia activa y reactiva en los nodos de la red, en funcin de las tensiones y ngulos de las barras. Existen variadas funciones objetivos que puede considerar un modelo OPF, entre las cuales se pueden mencionar (Ristanovic, 1996): Minimizacin de los costos por generacin de potencia activa, Minimizacin de prdidas de potencia activa, Minimizacin del cambio en las variables de control, Minimizacin de la potencia no servida, etc. Una gran variedad de tcnicas de optimizacin han sido aplicadas para resolver OPF (Momoh y ElHawary, 1999): Programacin lineal. Versiones hbridas de programacin lineal y programacin entera. Mtodos de punto interior. Programacin no lineal.

35

Programacin cuadrtica.

Soluciones basadas en condiciones de Newton. El presente trabajo se presentara dos casos de sistemas de potencia, el primero es un sistema compuesto por dos nodos y modelado AC el cual debido a su complejidad para su resolucin y formulacin general se opto por resolver el segundo caso el cual es un sistema multimodal y modelado DC. El anlisis se har sin restricciones de desigualdad; y solucin por mtodo de Newton-Raphson. Se abordaran el mtodos antes mencionado para el modelamiento y resolucin, considerando funcin objetivo que contempla la minimizacin de costos por generacin de potencia activa. 4.2 El problema de flujo optimo de potencia Un estudio de flujos de potencia ptimo es utilizado ampliamente en la industria elctrica para diferentes aplicaciones, que van desde estudios de planeacin hasta operacin de los sistemas. El principal objetivo de un OPF es optimizar las condiciones de operacin en estado estacionario de un sistema elctrico de potencia. Un OPF ajusta las cantidades controlables para optimizar una funcin objetivo mientras satisface un conjunto de restricciones operativas . Una funcin objetivo puede incorporar aspectos econmicos, de seguridad o medioambientales, que se resuelve utilizando tcnicas de optimizacin adecuadas. Las restricciones son leyes fsicas que gobiernan a los generadores, el sistema de transmisin, lmites constructivos de los equipos elctricos y estrategias operativas. Esta clase de problema es expresado como un problema de programacin no lineal, con la funcin objetivo expresada como una funcin no lineal, y las restricciones expresadas como ecuaciones lineales y no lineales.

4.2.1 Formulacion general Se han considerado varias funciones objetivo en un OPF, pero la que ms frecuentemente se usa toma en cuenta los costos de generacin, la que refleja aspectos econmicos del sistema de potencia. De aqu que la formulacin matemtica del OPF se enfoca en minimizar el costo de generacin de potencia activa por un ajuste adecuado de las variables de control. De forma general, el OPF puede ser formulado como un problema de optimizacin no lineal con restricciones, que matemticamente se expresa como:

36

El conjunto de restricciones de igualdad, de la ecuacin anterior est compuesto por las ecuaciones de balance de potencia en las barras. Por su parte el conjunto de restricciones de desigualdad, representa las restricciones del vector de variables de control y de estado, tales como cotas y lmites de operacin. El planteamiento del problema en forma general que se tratara en este trabajo se puede representar como: Minimizar Sujeto a

4.2.2 Variables Las variables de control y de estado a considerar en el OPF se resumen en la Figura 4.1. Se considera la simbologa estndar utilizada en la literatura relacionada.

G
,

Figura 4.1 Variables de control y de estado Donde , son variables de control, corresponden a la potencia activa y reactiva inyectadas por y , son variables de estado, corresponden al mdulo de la tensin y y , son parmetros que representan la potencia activa y reactiva

el generador. Por su parte, su ngulo respectivamente. de la carga o consumo.

El vector x contiene las variables de control y estado, incluye: : Potencia activa generador j: : Potencia reactiva generador j: : Voltaje en el bus i:

37

: Angulo de voltaje en el bus i: : Tap del transformador j: Siendo el conjunto de buses en la red elctrica y , el conjunto de

generadores y transformadores conectados a los buses (o nodos). El vector x entonces ser: Ec.4.1 Otro parmetro a considerar es la matriz compleja de admitancia nodal (Y), representada por sus elementos , que define la relacin entre corrientes y tensiones nodales del sistema. Ec.4.2

Ec.4.3 Si en el arco (ij) existe un transformador, entonces los parmetros de la matriz de admitancia nodal consideran implcitamente el efecto del tap. Ec.4.4 Ec.4.5

4.2.3 Funcion objetivo La funcin objetivo representa el criterio (o ndice de desempeo) usado para optimizar. La seleccin de la funcin objetivo obedece a un anlisis cuidadoso de la seguridad y economa del sistema elctrico de potencia. Algunas de las funciones objetivo empleadas en un estudio de OPF son: Minimizar el costo de generacin. Minimizar las prdidas de transmisin de potencia activa. Minimizar las prdidas de transmisin de potencia reactiva. Minimizar el costo por interrupcin de carga. Minimizar el nmero de reprogramacin de los controles. Minimizar emisiones contaminantes por parte de los generadores trmicos. La minimizacin de costos por generacin de potencia activa conforma la funcin objetivo para el OPF considerada en este trabajo. Para cada generador de la red, se supone conocida su funcin de costos en las potencias activas generadas, tal y como se detalla a continuacin. Ec.4.6

38

4.2.4 Restricciones de igualdad Las restricciones de igualdad son tpicamente las ecuaciones de balance de carga, las que se obtienen al imponer una restriccin de balance de potencia activa y reactiva en todos los nodos del sistema. En un punto de operacin en estado estable, la potencia generada debe ser tal que sea suficiente para cubrir la demanda ms las prdidas en la red. Las ecuaciones de balance consideran un punto de equilibrio de potencia activa y reactiva que debe satisfacer cada una de los nodos: Ec.4.7 Ec.4.8

Para un caso DC la ecuacin a considerar es: Ec.4.9

Para un caso AC las ecuaciones a considerar son: Ec.4.10 Ec.4.11

4.2.5 Restricciones de desigualdad Las restricciones de desigualdad consideran los lmites que deben satisfacer las variables de control y estado. Estas restricciones reflejan los lmites operativos impuestos a los dispositivos y al sistema elctrico de potencia. Las principales restricciones de desigualdad consideradas en un OPF son: Lmites de potencia activa y reactiva de generacin: La potencia activa y reactiva asignada a las unidades de generacin deben estar dentro de lmites de operacin. Esta restriccin refleja los lmites operativos y trmicos que un generador debe satisfacer.

Ec.4.12 Ec.4.13

39

Donde

son los limites de potencia activa mnima y mxima, respectivamente, para el y son los limites de potencia reactiva mnima y mxima,

i-esimo generador;

respectivamente para el i-esimo generador. Lmites de flujos en las ramas.- Con la finalidad de mantener la seguridad en los sistemas de potencia, los enlaces (lneas o transformadores) no deben ser sobrecargados. Por lo tanto, es necesario definir lmites para todas las ramas (o para un grupo de ellas). Estos lmites pueden deberse a restricciones trmicas de los equipos o por consideraciones de seguridad del sistema. Los lmites de los flujos se pueden formular como:

Donde los nodos j e i.

representa el mximo flujo de potencia activa permitido en la rama que conecta

Perfiles de voltaje.- Debido a que el voltaje en los nodos es uno de los criterios de seguridad e ndice de calidad de servicio ms importante, incluir una restriccin que mejore el perfil de voltaje de los nodos de carga del sistema es un aspecto importante a ser considerado en el problema de optimizacin. Los voltajes en los nodos de generacin son constantes, mientras que el nivel de voltaje en los nodos de carga debe mantenerse muy cercano a un voltaje de referencia. Matemticamente esta restriccin se puede definir mediante:

Donde

representa la magnitud del voltaje en el i-esimo nodo de carga,

representa la

magnitud de voltaje de referencia, en general definido como

Otras restricciones que pueden ser incluidas en un OPF son: Lmites del cambiador de fase de un transformador. Lmites de las variables de control de los dispositivos FACTS. Lmites de compensacin de potencia reactiva. Requerimientos de reserva rodante. Lmites de emisin de contaminantes al medio.

40

4.3 Casos de flujo optimo de potencia (OPF). A continuacin se presentaran dos casos de sistemas de potencia a los cuales se analizaran y se desarrollaran aplicando todo lo antes mencionado adems estos se resolvern en Python mostrando sus resultados. 4.3.1 OPF de un sistema de dos nodos y modelado AC: sin restricciones de desigualdad. Por mtodo de Newton-Raphson

A continuacin plantearemos un ejemplo sencillo de un sistema de potencia compuesto por dos nodos y un generador. Dicho sistema se resolver por medio de un anlisis AC, en este caso si incluimos las potencias reactivas tanto generadas como las demandadas. En este sistema se busca garantizar una operacin segura y encontrar un punto de operacin econmico, la operacin econmica se refiere a reducir los costos por la utilizacin de la energa elctrica esto incluye los costos de produccin, transporte y consumo.

Figura 4.2 Diagrama unifilar de sistema de dos nodos

1. Planteamiento del problema Min Sujeto a: Balance nodal de potencia real:

Balance de potencia reactiva:

41

Donde : Flujo de potencia real que va del nodo 1 al nodo 2 : Flujo de potencia reactiva que va del nodo 1 al nodo 2

Teniendo en cuenta que:

Sabemos que:

Anlogamente tenemos:

2. Ecuacin de LaGrange

Planteando las condiciones de primer orden:

42

3. Mtodo de Newton-Raphson Se proceder a resolverlo mediante el mtodo de Newton-Raphson descrito en la seccin 2.2. El mtodo esta definido por.

Donde

es el vector de variables.

43

: Se conoce como el Hessiano, definido as:

Para el caso en estudio el Hessiano queda definido como:

En donde B es la matriz siguiente:

Dejando claro que

Figura 4.3 Hessiano sistema de dos nodos

44

Se proceder a resolver el problema mediante el programa elaborado en Python. Los datos del problema son los siguientes: La ecuacin de costos de cada generador esta definida por:

Reactancias:

Introducimos los datos en nuestra interfaz:

Al correr el programa los resultados son los siguientes

Los resultados muestran el flujo de potencia activa y reactiva en MW y en MVAR respectivamente, en la lnea, el flujo va del nodo 1 hacia el nodo 2.

45

Muestra el costo de generacin en dlares del generador conectado en el nodo 1, teniendo claro que este costo es el ms econmico en lo que respecta a la generacin ya que eso es lo que se buscaba minimizar los costos por generacin. Tambin muestra el valor de las variables duales o costos marginales, las cuales representa la cantidad en dlares por cada MW producido o demandado, cabe sealar que: : Es el costo de la energa activa, al incrementar un MWh de generacin, para este caso es coincidente con el precio nodal de la demando (costo marginal de la demanda), al requerir un MWh adicional. : Es el costo de la energa activa al incrementar un MWh en la demanda en el nodo dos, observamos que el precio de la energa en este nodo es mayor que el precio en el nodo 1 debido principalmente a las prdidas producidas por la impedancia de la lnea. : Costo de la energa reactiva en el nodo de generacin, para el caso es cero pues nuestro modelo esta basado en costos de generacin activa y no reactiva. : Costo de la energa reactiva en el nodo de carga, en este caso es aproximadamente cero, pero no cero, debido a los costos de traslado y perdidas del sistema.

A continuacin se muestra el sistema con todos sus flujos y costos marginales.

Figura 4.4 Diagrama Unifilar con flujos en las lneas y costos marginales AC A partir del anlisis mostrado del OPF de un sistema de dos nodos modelado AC, podemos observar que la solucin no es trivial ya que el Hessiano formado es demasiado grande, lo cual para un sistema compuesto por ms nodos se complicara el anlisis y la elaboracin del programa. Por ende se opta por enfocarse y enfatizar mas en el modelado DC que se presenta a continuacin.

46

4.3.2 OPF de un sistema multimodal y modelado DC: sin restricciones de desigualdad. Por mtodo de Newton-Raphson El supuesto bsico del modelo de flujo DC, es que este solo se centra en las potencias activas tanto en las generadas como las de flujo en las lneas interconectadas entre los buses. Por lo tanto este anlisis se realiza tomando en cuenta las reactancias de lnea as como las potencias generadas como las demandadas. Por lo tanto se asume que no hay cambios en los voltajes y por tanto no hay generacin ni flujos de potencia reactiva. Las consideraciones que se toman para un anlisis DC son las siguientes: Se ignoran las perdidas de potencia activa Las diferencias de fase angular entre los nodos de cualquier rama son pequeos Se considera que las magnitudes de las tensiones de nodo son aproximadamente 1 p.u.

Figura 4.5 Diagrama Unifilar de sistema de cuatro nodos

La formulacin del modelo DC de flujo de potencia se obtiene a partir de la modificacin de la representacin general del flujo de potencia AC, lo cual puede ser ilustrado en las siguientes ecuaciones:

Ec.4.14 Ec.4.15 Recordando que:

47

Ec.4.16 Donde: : Potencia activa del nodo i : Potencia reactiva del nodo i : Magnitud de voltaje del nodo i : Magnitud de voltaje del nodo j : ngulo de fase del voltaje en el nodo i : ngulo de fase del voltaje en el nodo j : Conductancia de lnea entre nodos i-j : Susceptancia de lnea entre nodos i-j : Resistencia de lnea entre nodos i-j : Reactancia de lnea entre nodos i-j N: Nmero total de nodos existentes en el sistema Para modificar el modelo AC de flujo de potencia a un modelo DC, las siguientes simplificaciones son consideradas: La magnitud del voltaje en por unidad para cada bus se aproxima a 1 p.u. La resistencia de lnea es ignorada debido a que es muy pequea comparada con la reactancia de lnea entonces que tambin , De esta forma para todas las lneas. Esto implica

para todas las lneas. Por lo tanto: Ec.4.17

Se asume que la diferencia de ngulos de fase es muy pequea, entonces, pueden aproximarse de la siguiente manera: Ec.4.18 Ec.4.19 Las simplificaciones anteriores, cumplen con las caractersticas de las redes de transmisin y no conllevan a errores significativos en los resultados de la distribucin de flujos de potencia activa. Cuando se agregan a la ecuacin de potencia activa entonces el resultado es el siguiente: Ec.4.20 Entonces la ecuacin de flujo de potencia en las lneas de transmisin queda definida de la siguiente manera: Ec.4.21

48

1. Planteamiento Se va a plantear el problema del OPF con el unifilar de la figura 4.5 La funcin a minimizar esta compuesta por las ecuaciones de costos de cada uno de los generadores del sistema dada por Ec.4.22 Por lo tanto la ecuacin a minimizar esta definida como: Min Ec.4.23

En donde estar sujeta a: Ecuaciones de balance nodal dadas por:

En donde : Es la potencia demandada en cada uno de los nodos del sistema; unidades : Direccin de flujo de potencia de lnea interconectada entre lo nodos; unidades : Potencia generada por cada uno de los generadores conectados a los nodos del sistema; unidades : Reactancia de lnea interconectada entre los nodos; unidades A cada ecuacin nodal se le asigna un multiplicador de LaGrange ( , Para el anlisis se tomara como referencia Es de tener en cuenta que estas ecuaciones de balance nodal son las mas importantes en nuestro anlisis ya que a cada una de ellas se les asigna una variable , la cual son llamadas variables , , )

duales, las cuales son los costos marginales del sistema. Es el costo al cual se remunera la energa producida por cada generador del sistema. 2. Ecuacin de LaGrange Planteamos la ecuacin de LaGrange en funcin de cada una de las variables, as:

49

A continuacin planteamos las condiciones de primer orden, que son las derivadas parciales de la ecuacin de LaGrange con respecto a cada una de las variables.

3. Mtodo de Newton-Raphson Se proceder a resolverlo mediante el mtodo de Newton-Raphson descrito en la seccin 2.2. El mtodo esta definido por.

Donde

es el vector de variables.

: Se conoce como el Hessiano, definido as:

50

Para el caso en estudio el Hessiano queda definido como:

En donde A es la matriz siguiente

0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0

0 0 0 0 0

0 0 0 0 0 0 0 0 0 0

0 0

0 0 0

0 0 0 0

0 0 0 0

0 0 0 0

0 0

Figura 4.6 Hessiano sistema de cuatro buses

Por lo tanto:

51

Se proceder a resolver el problema con le programa elaborado en Python. Los datos del problema son los siguientes: La ecuacin de costos de cada generador esta definida por:

Reactancias:

Primero introducimos los datos del problema a nuestra interfaz

Con los datos ya introducidos, procedemos a correr nuestro programa, obteniendo los resultados siguientes:

52

Primero se observa la magnitud de voltaje en pu de cada uno de los buses del sistema, para el caso todos constantes ya que se esta haciendo un anlisis DC en el cual todas las magnitudes de voltajes son constantes e iguales a 1. Al lado de los voltajes se muestran los flujos en las lneas. Tenemos las potencias generadas por cada generador para poder satisfacer la demanda. Luego tenemos el costo total de generacin en dlares incluyendo ambos generadores. El programa tambin reporta, los flujos en las lneas de transmisin, la potencia inyectada por cada central, los costos marginales nodales. Las variables duales representan los costos marginales de la demanda en cada nodo y son los valores con los que remunera la energa producida por cada generador. Este anlisis esta hecho con el objetivo de optimizar las condiciones de operacin de un sistema. Por lo tanto se ha encontrado la solucin ms econmica en produccin, transporte y consumo. A continuacin se muestra el diagrama del sistema con todos sus flujos y costos marginales en cada nodo.

Figura 4.7 Diagrama Unifilar con flujos en las lneas y sus costos marginales DC

53

54

CAPITULO 5. CONCLUSIONES Y RECOMENDACIONES 5.1 Conclusiones Se desarrollo el programa de anlisis de flujo de carga pudindose analizar SEP de gran tamao y considerando el modelado de transformadores con tap, de dos y tres devanados, y el modelado de las lneas de transmisin.

Se desarrollo una aplicacin para el OPF en modelado AC, con la limitante del anlisis de un sistema en especfico debido a la complejidad de este tipo de modelaje que toma en cuenta la forma de inyeccin de la potencia real y reactiva de manera sinusoidal y su complejidad de programacin.

Las simplificaciones efectuadas al modelo AC de OPF, dieron lugar al modelaje DC, para este ultimo se desarrollo el programa de anlisis de OPF manera general pudindose analizar diferentes tipos de sistemas elctricos desde el punto de vista econmico.

En los programas desarrollados en el intrprete libre (PYTHON), se tomo como metodologa de solucin el mtodo iterativo de NEWTON por ser este uno de los mtodos ms poderosos para resolver este tipo de problemas no lineales y uno de los ms conocidos.

5.2 Recomendaciones Por parte del departamento de Ciencias Energticas y Fludicas, de la Universidad Centroamericana Jos Simen Caas, UCA, El Salvador, seguir ahondando en el

presente tema de investigacin, que constituye una poderosa herramienta de anlisis para el Ingeniero Electricista, en el campo de los SEP.

Buscar mtodos matemticos alternativos, para una convergencia de solucin ms rpida y eficaz en el uso fsico de memoria del computador en sistemas grandes.

Elaborar el modelaje de un OPF para anlisis de manera general e incluir las restricciones tcnicas de voltaje, ngulo, y lmites en la inyeccin de potencia de los generadores.

55

56

BIBLIOGRAFIA Duncan Glover J. / Mulukutla S. Sarma. Sistemas de Potencia. Anlisis y Diseo. 3.ed. Mxico D.F. 2003. 656 p. ISBN 970-686-291-9. D.P. Kothari / I.J. Nagrath. Sistemas Elctricos de Potencia. . 3.ed. Mxico D.F. 2008. 685 p. ISBN 0-07-049489-4. Federico Milano. Power System Modelling and Scripting. ETSII, University of Castilla - La Mancha 13071, Ciudad Real Spain. 551 p. ISBN 978-3-642-13668-9 Juan Eduardo Prez Retamales. [2001] Flujo de Potencia Optimo con programacin cuadrtica secuencial. Tesis para optar al grado de Magister en gestin de operaciones. Facultad de ciencias fsicas y matemticas, departamento de ingeniera industrial. Universidad de Chile. Oate Yumbla Pablo Enrique. [2008] Solucin del problema de flujos de potencia optimo con restricciones de seguridad por un optimizador de partculas modificado. Tesis Doctoral en Ingeniera Elctrica. Centro de Investigacin y Estudios Avanzados del I.P.N. Unidad Guadalajara. Saadat Hadi. Power System Analysis. New York: McGraw-Hill. 313 p. ISBN 0-07-012235-0. Soares Ramos Dorel / Dias Eduardo Mario. Sistemas Elctricos de Potencia. Regime Permanente. Volumen 2. Rio de Janeiro: Editora Guanabara Dois S.A. 224 p.

57

58

ANEXO A
PROGRAMA DE FLUJOS DE POTENCIA

59

from cvxopt import matrix, spmatrix, mul, div, sparse from math import atan, sin, cos, pi from scipy.linalg import inv from scipy import conjugate

def carga():#definiendo la funcin para cargar los datos del archivo interface f = open('datos14.txt', 'r'); lines = f.readlines(); f.close() global MVA #leyendo los MVA base MVAB=lines[2].split() MVA=int(MVAB[0]) #leyendo los parametros de buses ynames = lines[5].split() y = {} for name in ynames: y[name] = [] s=0 while s<1: for line in lines[6:]: yvalues = [float(yi) for yi in line.split()] if len(yvalues) == 0: break for name, value in zip(ynames, yvalues): y[name].append(value) s+=1 #leyendo los parametros de linea ul=8+len(y[name]) ul1=ul+1 ynames1 = lines[ul].split() y1 = {} for name1 in ynames1: y1[name1] = [] d=0

1 A-1

while d<1: for line in lines[ul1:]: yvalues1 = [float(yi) for yi in line.split()] if len(yvalues1) == 0: break for name1, value1 in zip(ynames1, yvalues1): y1[name1].append(value1) d+=1 #leyendo los parametros de lineas en paralelo ul2=11+len(y[name])+len(y1[name1]) ul3=ul2+1 ynames2 = lines[ul2].split() y2 = {} for name2 in ynames2: y2[name2] = [] e=0 while e<1: for line in lines[ul3:]: yvalues2 = [float(yi) for yi in line.split()] if len(yvalues2) == 0: break for name2, value2 in zip(ynames2, yvalues2): y2[name2].append(value2) e+=1 #leyendo los parametros de transformadores de 2 devanados ul4=14+len(y[name])+len(y1[name1])+len(y2[name2]) ul5=ul4+1 ynames3 = lines[ul4].split() y3 = {} for name3 in ynames3: y3[name3] = [] f=0 while f<1: for line in lines[ul5:]: yvalues3 = [float(yi) for yi in line.split()] if len(yvalues3) == 0: break

A-2 2

for name3, value3 in zip(ynames3, yvalues3): y3[name3].append(value3) f+=1 #leyendo los parmetros de transformadores de 3 devanados ul6=17+len(y[name])+len(y1[name1])+len(y2[name2])+len(y3[name3]) ul7=ul6+1 ynames4 = lines[ul6].split() y4 = {} for name4 in ynames4: y4[name4] = [] g=0 while g<1: for line in lines[ul7:]: yvalues4 = [float(yi) for yi in line.split()] if len(yvalues4) == 0: break for name4, value4 in zip(ynames4, yvalues4): y4[name4].append(value4) g+=1 #generando matrices de datos global nbr4,nlt,nnbus,anges,tbus,V,nombus,pes,qes,nbr,nl,nr,R,x,lip,lsp,lipr,lspr,B,A #datos de buses nnbus=len(y['nombre'])# numero de buses del sistema anges=matrix(y['rad'],(nnbus,1)) tbus=matrix(y['bus'],(nnbus,1))#bus PQ=0, bus PV=2, bus referencia=1 V=matrix(y['vol'],(nnbus,1)) nombus=matrix(y['nombre'],(nnbus,1)) prload=matrix(y['loadMW'],(nnbus,1)) preacload=matrix(y['loadMvar'],(nnbus,1)) prgene=matrix(y['generaMW'],(nnbus,1)) preacgene=matrix(y['generaMvar'],(nnbus,1)) lip=matrix(y['lpinf'],(nnbus,1)) lsp=matrix(y['lpsup'],(nnbus,1)) lipr=matrix(y['lprinf'],(nnbus,1)) lspr=matrix(y['lprsup'],(nnbus,1))

# parametros de las lineas

A-3 3
A-1

nbr1=len(y1['nl'])# numero de lineas del sistema nomlin=matrix(y1['nomlin'],(nbr1,1))#nombre de linea nl1=matrix(y1['nl'],(nbr1,1))#linea desde nr1=matrix(y1['nr'],(nbr1,1))#linea hasta R1=matrix(y1['R'],(nbr1,1))# resitencia de linea x1=matrix(y1['X'],(nbr1,1))#reactancia de linea B1=matrix(y1['B'],(nbr1,1))#suceptancia de linea A1=matrix(y1['a'],(nbr1,1))#linea o tranformador

#parametros de lineas en paralelo nbr2=len(y2['nl1'])# numero de lineas en //del sistema nomlinp=matrix(y2['nlp'],(nbr2,1))#nombre de linea // nlp1=matrix(y2['nl1'],(nbr2,1))#linea desde nrp1=matrix(y2['nr1'],(nbr2,1))#linea hasta Rp=matrix(y2['R1'],(nbr2,1))# resitencia de linea xp=matrix(y2['X1'],(nbr2,1))#reactancia de linea Bp=matrix(y2['B1'],(nbr2,1))#suceptancia de linea lp=matrix(y2['a1'],(nbr2,1))

plpd=0 plph=0 cb=0 cdl=0 cp=0 #conteo de bloques de lineas en paralelo if nbr2!=0: for k in range(0,nbr2-1): if nlp1[k]!=nlp1[k+1] or nrp1[k]!=nrp1[k+1]: cp+=1 cp=cp+1 # conteo lineas en cada bloque lan=spmatrix([],[],[],(cp,1),tc='d') nlpf=spmatrix([],[],[],(cp,1),tc='d') nrpf=spmatrix([],[],[],(cp,1),tc='d') req=spmatrix([],[],[],(cp,1),tc='d') xeq=spmatrix([],[],[],(cp,1),tc='d') beq=spmatrix([],[],[],(cp,1),tc='d')

4 A-4

Ap=matrix(1,(cp,1),tc='d') if cp>1: j=spmatrix([],[],[],(cp+1,1),tc='d') if cp==1: j=spmatrix([],[],[],(cp,1),tc='d') for k in range(0,nbr2): lp[k]=nomlinp[k]-nbr1-1 if lp[k]==0: plpd=int(nlp1[k]) plph=int(nrp1[k]) nlpf[cb]=plpd nrpf[cb]=plph j[cb]=0 if lp[k]!=0: if nlp1[k]==plpd and nrp1[k]==plph: cdl+=1 else: plpd=int(nlp1[k]) plph=int(nrp1[k]) j[cb+1]=k nlpf[cb+1]=plpd nrpf[cb+1]=plph cdl+=1 lan[cb]=cdl cdl=0 cb+=1 if cp-1==cb and lp[k]==nbr2-1 and cp>1: cdl+=1 lan[cb]=cdl j[cb+1]=k if cp==1: cdl+=1 lan[cb]=cdl nlpf[cb]=plpd nrpf[cb]=plph j[cb]=cdl #calculo de parametros lineas en paralelo

5 A-5

if cp>1: for k in range(0,cp): if cp-1>k: for i in range(int(j[k]),int(j[k+1])): req[k]=req[k]+1/(Rp[i]) xeq[k]=xeq[k]+1/(xp[i]) beq[k]=beq[k]+1/(Bp[i]) req[k]=1/req[k] xeq[k]=1/xeq[k] beq[k]=1/beq[k] if cp-1==k: for i in range(int(j[k]),int(j[k+1])+1): req[k]=req[k]+1/(Rp[i]) xeq[k]=xeq[k]+1/(xp[i]) beq[k]=beq[k]+1/(Bp[i]) req[k]=1/req[k] xeq[k]=1/xeq[k] beq[k]=1/beq[k]

if cp==1: for k in range(0,cp): for i in range(0,int(j[k])): req[k]=req[k]+1/(Rp[i]) xeq[k]=xeq[k]+1/(xp[i]) beq[k]=beq[k]+1/(Bp[i]) req[k]=1/req[k] xeq[k]=1/xeq[k] beq[k]=1/beq[k]

#parametros de transformadores de 2 devanados nbr3=len(y3['nl2t'])# numero de transformadores de 2 dev nomt2=matrix(y3['nomtransf2'],(nbr3,1))#nombre de transformador nlt2=matrix(y3['nl2t'],(nbr3,1))#desde nrt2=matrix(y3['nr2t'],(nbr3,1))#hasta R2=matrix(y3['R2'],(nbr3,1))# resitencia x2=matrix(y3['X2'],(nbr3,1))#reactancia B2=matrix(y3['B2'],(nbr3,1))#susceptancia

6 A-6

A2=matrix(y3['a2'],(nbr3,1))#relacion de tranformacion

#parametros de transformadores de 3 devanados nbr4=len(y4['nl3t'])# numero de transformadores de 3 devanados nomt3=matrix(y4['nomtransf3'],(nbr4,1))#nombre de transformador nlp2=matrix(y4['nl3t'],(nbr4,1))#desde np12=matrix(y4['nr3t1'],(nbr4,1))#hasta secundario np13=matrix(y4['nr3t2'],(nbr4,1))#hasta terciario rps=matrix(y4['R12'],(nbr4,1))# resitencia primario-secundario rpt=matrix(y4['R13'],(nbr4,1))# resitencia primario-terciario rst=matrix(y4['R23'],(nbr4,1))# resitencia secundario-terciario xps=matrix(y4['X12'],(nbr4,1))# reactancia primario-secundario xpt=matrix(y4['X13'],(nbr4,1))# reactancia primario-terciario xst=matrix(y4['X23'],(nbr4,1))# reactancia secundario-terciario bps=matrix(y4['B12'],(nbr4,1))# susceptancia primario-secundario bpt=matrix(y4['B13'],(nbr4,1))# susceptancia primario-terciario bst=matrix(y4['B23'],(nbr4,1))# susceptancia secundario-terciario A3=matrix(y4['a3'],(nbr4,1))#relacion de tranformacion nc=matrix(y4['nc'],(nbr4,1))#nodo comun del transformador de tres devanados x31=spmatrix([],[],[],(nbr4,1),tc='d') x32=spmatrix([],[],[],(nbr4,1),tc='d') x33=spmatrix([],[],[],(nbr4,1),tc='d') x12=spmatrix([],[],[],(nbr4,1),tc='d') x13=spmatrix([],[],[],(nbr4,1),tc='d') r31=spmatrix([],[],[],(nbr4,1),tc='d') r32=spmatrix([],[],[],(nbr4,1),tc='d') r33=spmatrix([],[],[],(nbr4,1),tc='d') r12=spmatrix([],[],[],(nbr4,1),tc='d') r13=spmatrix([],[],[],(nbr4,1),tc='d') b31=spmatrix([],[],[],(nbr4,1),tc='d') b32=spmatrix([],[],[],(nbr4,1),tc='d') b33=spmatrix([],[],[],(nbr4,1),tc='d') b12=spmatrix([],[],[],(nbr4,1),tc='d') b13=spmatrix([],[],[],(nbr4,1),tc='d') for k in range(0,nbr4): #reactancia x31[k]=0.5*(xps[k]+xpt[k]-xst[k])

7 A-7

x32[k]=0.5*(xps[k]-xpt[k]+xst[k]) x33[k]=0.5*(-xps[k]+xpt[k]+xst[k]) x12[k]=x31[k]+x32[k] x13[k]=x31[k]+x33[k] #resistencia r31[k]=0.5*(rps[k]+rpt[k]-rst[k]) r32[k]=0.5*(rps[k]-rpt[k]+rst[k]) r33[k]=0.5*(-rps[k]+rpt[k]+rst[k]) r12[k]=r31[k]+r32[k] r13[k]=r31[k]+r33[k] #susceptancia b31[k]=0.5*(bps[k]+bpt[k]-bst[k]) b32[k]=0.5*(bps[k]-bpt[k]+bst[k]) b33[k]=0.5*(-bps[k]+bpt[k]+bst[k]) b12[k]=b31[k]+b32[k] b13[k]=b31[k]+b33[k] nbr=nbr1+cp+nbr3+3*nbr4 # Dimension de matrices si existen lineas en paralelo if nbr2!=0: A=sparse([A1,Ap,A2,A3,1,1]) A=matrix(A) nlt=sparse([nomlin,nomlinp,nomt2,nomt3]) nlt=matrix(nlt) R=sparse([R1,req,R2,r31,r32,r33]) R=matrix(R) x=sparse([x1,xeq,x2,x31,x32,x33]) x=matrix(x) B=sparse([B1,beq,B2,b31,b32,b33]) B=matrix(B) nl=sparse([nl1,nlpf,nlt2,nlp2,nc,nc]) nl=matrix(nl) nr=sparse([nr1,nrpf,nrt2,nc,np12,np13]) nr=matrix(nr) #Dimension de matrices si no existen lineas en paralelo if nbr2==0: A=sparse([A1,A2,A3,1,1]) A=matrix(A)

8 A-8

nlt=sparse([nomlin,nomt2,nomt3]) nlt=matrix(nlt) R=sparse([R1,R2,r31,r32,r33]) R=matrix(R) x=sparse([x1,x2,x31,x32,x33]) x=matrix(x) B=sparse([B1,B2,b31,b32,b33]) B=matrix(B) nl=sparse([nl1,nlt2,nlp2,nc,nc]) nl=matrix(nl) nr=sparse([nr1,nrt2,nc,np12,np13]) nr=matrix(nr)

#calculo potencias limites en p.u for i in range(0,nnbus): lip[i]=lip[i]/MVA lsp[i]=lsp[i]/MVA lipr[i]=lipr[i]/MVA lspr[i]=lspr[i]/MVA #potencias en p.u pes=spmatrix([],[],[],(nnbus,1)) qes=spmatrix([],[],[],(nnbus,1)) #generando los valores de potencia en p.u for i in range(0,nnbus): pes[i]=(prgene[i]-prload[i])/MVA qes[i]=(preacgene[i]-preacload[i])/MVA

def ybus():# funcion que genera la matriz ybus global Ypa, Ypm, Y, bc,ds #matrices necesarias para generar la matriz de admitancias Ybus xc=spmatrix([],[],[],(nbr,1),tc='z') bc=spmatrix([],[],[],(nbr,1),tc='z') x1=spmatrix([],[],[],(nbr,1)) y1=spmatrix([],[],[],(nbr,1)) Y=spmatrix([],[],[],(nnbus,nnbus),tc='z') y=matrix(1,(nbr,1)) Ypr=spmatrix([],[],[],(nnbus,nnbus))

9 A-9

Ypi=spmatrix([],[],[],(nnbus,nnbus)) Ypm=spmatrix([],[],[],(nnbus,nnbus)) Ypa=spmatrix([],[],[],(nnbus,nnbus)) #iniciando la formacion de Ybus, en rectangular int() s=0 cx=0 bx=0 while s<=nbr-1: int(x[s,0]) cx=matrix(x[s]*1j) xc[s,0]=cx int(B[s,0]) bx=matrix(B[s]*1j) bc[s,0]=bx s+=1 z=R+xc ds=div(y,z) #Ybus fuera de la diagonal for d in range(0,nbr): if nl[d] > 0 and nr[d] > 0: x0=int(nl[d])-1 y0=int(nr[d])-1 Y[x0,y0]=Y[x0,y0]-ds[d]/A[d] Y[y0,x0]=Y[x0,y0] #Ybus en la diagonal for n in range(0,nnbus): for k in range(0,nbr): x1[k]=int(nl[k])-1 y1[k]=int(nr[k])-1 if x1[k]==n: Y[n,n]=Y[n,n]+ ds[k]/(A[k]**2)+bc[k]/2 if y1[k]==n: Y[n,n]=Y[n,n]+ ds[k]+bc[k]/2

#pasando Ybus de rectangular a polar for n in range(0,nnbus):

10 A-10

for k in range(0,nnbus): Ypr[n,k]=Y[n,k].real Ypi[n,k]=Y[n,k].imag #magnitud de Ybus Ypm[n,k]=abs(Y[n,k]) if Ypr[n,k] > 0 or Ypr[n,k] < 0: if n==k: #angulo de Ybus en la diagonal Ypa[n,k]=atan(Ypi[n,k]/Ypr[n,k]) if n<k or n>k: #angulo de Ybus fuera de la diagonal Ypa[n,k]=atan(Ypi[n,k]/Ypr[n,k])+pi if Ypr[n,k]==0 and Ypi[n,k]>0: Ypa[n,k]=pi/2 if Ypr[n,k]==0 and Ypi[n,k]<0: Ypa[n,k]=-pi/2

return Y

def newton():#funcion metodo de newton global jac, delta, pcal,qcal,iterac,dpi,dqi aas=spmatrix([],[],[],(nnbus,1)) bbs=spmatrix([],[],[],(nnbus,1)) ngs=spmatrix([],[],[],(nnbus,1)) nss=spmatrix([],[],[],(nnbus,1)) #declaracion de matrices y variables utilizadas it=0#numero de iteraciones er = 0.001 #tolerancia dip=5 diq=5

#inicio metodo de newton while (dip and diq) > er and it<=10: pcal=spmatrix([],[],[],(nnbus,1),tc='d') qcal=spmatrix([],[],[],(nnbus,1),tc='d') if it==0: tbuscam=matrix(1,(nnbus,1),tc='d')

11 A-11

aa=0 bb=0 for i in range(0,nnbus): for k in range(0,nnbus): #calculo de potencia real pcal[i]= pcal[i]+ V[i]*Ypm[i,k]*V[k]*cos(Ypa[i,k]+anges[k]-anges[i]) #calculo de potencia reactiva qcal[i]= qcal[i]-V[i]*Ypm[i,k]*V[k]*sin(Ypa[i,k]+anges[k]-anges[i])

#primera consideracion de limites de potencia reactiva if it==0: for i in range(1,nnbus): if tbus[i]==2 or tbuscam[i]==0: if qcal[i]<lipr[i] and lipr[i]>0: qcal[i]=lipr[i] tbus[i]=0 tbuscam[i]=0 else: tbuscam[i]=1 #tbus[i]=2 if qcal[i]>lspr[i]: qcal[i]=lspr[i] tbus[i]=0 tbuscam[i]=0 else: tbuscam[i]=1 #tbus[i]=2 cbpvpq=0 for i in range(1,nnbus): if tbuscam[i]==0: cbpvpq+=1

bac=matrix(1,(cbpvpq,1),tc='d') bacaux=matrix(1,(cbpvpq,1),tc='d') bacc=0 for i in range(1,nnbus): if tbuscam[i]==0:

12 A-12

bac[bacc]=nombus[i] bacc+=1 for i in range(0,cbpvpq): bacaux[i]=int(bac[i])-1

#conteo de buses PV y PQ for a in range(0,nnbus): if tbus[a] ==2: aa = aa+1 if tbus[a] == 0: bb = bb+1

#dimensiones submatrices jacobianas omj=2*nnbus-aa-2 omj1=nnbus-1 omj2=omj1-aa #matrices necesarias solo en la primera iteracion if it==0: jac=matrix(0,(omj,omj),tc='d') delta=matrix(0,(omj,1),tc='d') iterac=spmatrix([],[],[],(omj,1),tc='d') ite=matrix(0,(omj,1),tc='d')

#Declarcion de matrices dpi=spmatrix([],[],[],(nnbus-1,1)) dqi=spmatrix([],[],[],(omj2,1)) j1=matrix(0,(omj1,omj1),tc='d') j2=matrix(0,(omj1,omj2),tc='d') j3=matrix(0,(omj2,omj1),tc='d') j4=matrix(0,(omj2,omj2),tc='d') jp=spmatrix([],[],[],(omj1,omj1)) jp1=spmatrix([],[],[],(omj1,omj1)) jp2=spmatrix([],[],[],(omj1,omj1)) npq=spmatrix([],[],[],(omj2,1)) pq=spmatrix([],[],[],(omj2,1)) jin=spmatrix([],[],[],(omj,omj)) mav3=spmatrix([],[],[],(nnbus,nnbus))

13 A-13

sang=spmatrix([],[],[],(nnbus,nnbus)) cang=spmatrix([],[],[],(nnbus,nnbus)) mav2=spmatrix([],[],[],(nnbus,nnbus)) pang=spmatrix([],[],[],(nnbus-1,nnbus-1)) pvol=spmatrix([],[],[],(nnbus-1,nnbus-1)) qang=spmatrix([],[],[],(nnbus-1,nnbus-1)) qvol=spmatrix([],[],[],(nnbus-1,nnbus-1)) mdpi=0 e=0 c=0 #seleccion de buses PQ for b in range(0,nnbus): if tbus[b]==0: pq[c]=int(nombus[b])-1 c+=1 d=0 #calculo de delta potencia real for i in range(1,nnbus): dpi[i-1]= pes[i]-pcal[i] if tbus[i]==0: #calculo de delta potencia reactiva dqi[d]= qes[int(pq[d])]-qcal[int(pq[d])] d+=1

#formando matriz de deltas for i in range(0,omj): if i<omj1: delta[i]=dpi[i] if i>=omj1: delta[i]=dqi[i-omj1] f=0 if it==0: for j in range(1,omj): if j<omj1: ite[j]=anges[j] if j>=omj1: ite[j]=V[int(pq[f])]

14 A-14

f+=1 #elementos que conformaran las submatrices jacobianas for p in range(0,nnbus): for q in range(0,nnbus): if p<q or p>q: mav3[q,p]=V[p]*V[q]*Ypm[p,q] mav2[q,p]=V[q]*Ypm[p,q] sang[q,p]=sin(Ypa[p,q]+anges[p]-anges[q]) cang[q,p]=cos(Ypa[p,q]+anges[p]-anges[q])

for p in range(1,nnbus): for q in range(1,nnbus): if p<q or p>q: pang[q-1,p-1]=-mav3[q,p]*sang[q,p]#elementos para j1 pvol[q-1,p-1]=mav2[q,p]*cang[q,p]#elementos para j2 qang[q-1,p-1]=-mav3[q,p]*cang[q,p]#elementos para j3 qvol[q-1,p-1]=-mav2[q,p]*sang[q,p]#elementos para j4

#fuera de diagonal de j1 for p in range(0,omj1): for q in range(0,omj1): if p<q or p>q: j1[q,p]=pang[q,p]

#diagonal j1 for i in range(1,omj1+1): for j in range(0,nnbus): if i>j or i<j: j1[i-1,i-1]=j1[i-1,i-1]+V[i]*V[j]*Ypm[i,j]*sin(Ypa[i,j]-anges[i]+anges[j])

#diagonal de j2 for i in range(1,omj1+1): for j in range(0,nnbus): jp1[i-1,i-1]=jp1[i-1,i-1]+V[j]*Ypm[i,j]*cos(Ypa[i,j]-anges[i]+anges[j]) jp1[i-1,i-1]=jp1[i-1,i-1]+V[i]*Ypm[i,i]*cos(Ypa[i,i]) for i in range(0,omj1): pvol[i,i]=jp1[i,i]

15 A-15

#diagonal de j3 for i in range(1,omj1+1): for j in range(0,nnbus): if i>j or i<j: jp[i-1,i-1]=jp[i-1,i-1]+V[i]*V[j]*Ypm[i,j]*cos(Ypa[i,j]-anges[i]+anges[j]) for i in range(0,omj1): qang[i,i]=jp[i,i]

#diagonal para j4 for i in range(1,omj1+1): for j in range(0,nnbus): jp2[i-1,i-1]=jp2[i-1,i-1]+V[j]*Ypm[i,j]*sin(Ypa[i,j]-anges[i]+anges[j]) jp2[i-1,i-1]=jp2[i-1,i-1]+V[i]*Ypm[i,i]*sin(Ypa[i,i]) for i in range(0,omj1): qvol[i,i]=-jp2[i,i]

sj2=0 for i in range(0,nnbus): if tbus[i]==0: npq[sj2]=int(nombus[i])-2 sj2+=1

sj3=0 s1=0 #fuera de diagonal de j2 for i in range(0,omj2): s1=int(npq[i]) for j in range(0,omj1): j2[j,sj3]=pvol[j,s1] sj3+=1

sj4=0 s2=0 #fuera de diagonal de j3 for i in range(0,omj2):

16 A-16

s2=int(npq[i]) for j in range(0,omj1): j3[sj4,j]=qang[s2,j] sj4+=1

sj5=0 sj6=0 s3=0 s4=0 #fuera de diagonal de j4 for i in range(0,omj2): s3=int(npq[i]) for j in range(0,omj2): if sj5==omj2: sj5=0 s4=int(npq[j]) j4[sj6,sj5]=qvol[s3,s4] sj5+=1 sj6+=1

#pasando submatriz j1 a matriz jacobiana for i in range(0,omj1): for g in range(0,omj1): jac[i,g]=j1[i,g] #pasando submatriz j2 a matriz jacobiana for i in range(0,omj1): for g in range(0,omj2): jac[i,g+omj1]=j2[i,g] #pasando submatriz j3 a matriz jacobiana for i in range(omj1,omj): for g in range(0,omj1): jac[i,g]=j3[i-omj1,g] #pasando submatriz j4 a matriz jacobiana for i in range(omj1,omj): for g in range(0,omj2): jac[i,g+omj1]=j4[i-omj1,g]

17 A-17

#invirtiendo la matriz jacobiana jin=inv(jac) jjin=matrix(jin,(omj,omj)) deltas= mul(jjin*delta) #despejando incognitas, angulos y voltajes iterac=ite+deltas #introduciendo los nuevos angulos y voltajes en sus respectivas #matrices para la nueva iteracion for i in range(0,omj): if i<omj1: anges[i+1]=iterac[i] ite[i]=iterac[i] if i>=omj1: V[int(pq[e])]=iterac[i] ite[i]=iterac[i] e+=1 #variables que calculan el error entre los varoles para #obtener los deltas verificando convergencia segun la tolerancia dip=max(abs(dpi)) diq=max(abs(dqi)) it+=1

return jac, V, anges

def fpotencia():#funcion que calcula los flujos en las lineas global fp,fq,Ii,Ij,fqdi,fpdi,ppr, ppre fp=spmatrix([],[],[],(nbr,1)) fq=spmatrix([],[],[],(nbr,1)) fpdi=spmatrix([],[],[],(nbr,1)) fqdi=spmatrix([],[],[],(nbr,1)) ppr=spmatrix([],[],[],(nbr,1)) ppre=spmatrix([],[],[],(nbr,1)) Ii=spmatrix([],[],[],(nbr,1),tc='z') Ij=spmatrix([],[],[],(nbr,1),tc='z') sij=spmatrix([],[],[],(nbr,1),tc='z') sji=spmatrix([],[],[],(nbr,1),tc='z') Vc=spmatrix([],[],[],(1,nnbus),tc='z')

18 A-18

for k in range(0,nnbus): Vc[k] = V[k]*cos(anges[k])+V[k]*sin(anges[k])*1j for k in range(0,nbr): i=int(nl[k])-1 j=int(nr[k])-1 Ii[k]=(Vc[i]-A[k]*Vc[j])*ds[k]/(A[k]**2)+bc[k]*Vc[i]/(2*A[k]**2) Ij[k]=(Vc[j]-Vc[i]/A[k])*ds[k]+bc[k]*Vc[j]/2 sij[k]=Vc[i]*conjugate(Ii[k])*MVA sji[k]=Vc[j]*conjugate(Ij[k])*MVA fp[k]=sij[k].real fq[k]=sij[k].imag fpdi[k]=sji[k].real fqdi[k]=sji[k].imag ppr[k]=abs(abs(fp[k])-abs(fpdi[k])) ppre[k]=abs(abs(fq[k])-abs(fqdi[k])) return fp, fq

def salida():#funcion que genera el reporte de flujos global angesgr angesgr=spmatrix([],[],[],(nnbus,1)) for i in range(0,nnbus): angesgr[i]=anges[i]*180/pi f = open('reporte'+str(nnbus)+'buses.txt', 'w') format = "%.3f" f.write('Magnitud de voltaje\n') f.write('Bus pu\n')

for k in range(0,nnbus): f.write(str(k+1)+' '+format %V[k]+'\n')

# print 'Magnitud de voltaje en pu' # print V f.write('\n') f.write('Angulo\n') f.write('Bus grados\n')

for k in range(0,nnbus): f.write(str(k+1)+' '+format %angesgr[k]+'\n')

# print 'Angulo en grados' # print angesgr

19 A-19

# imprimiendo flujo en las lineas f.write('\n') f.write('Potencia real MW\n') f.write('De hasta\n') #print 'Potencia real en MW' for k in range(0,nbr): i=int(nl[k])-1 j=int(nr[k])-1 f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %fp[k]+'\n') #print

# imprimiendo flujo en las lineas f.write('\n') f.write('Potencia real MW\n') f.write('De hasta\n') for k in range(0,nbr): i=int(nr[k])-1 j=int(nl[k])-1 f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %fpdi[k]+'\n') #print

f.write('\n') f.write('Potencia reactiva MVAR\n') f.write('De hasta\n') for k in range(0,nbr): i=int(nl[k])-1 j=int(nr[k])-1 f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %fq[k]+'\n') #print

#imprimiendo flujo en las lineas f.write('\n') f.write('Potencia reactiva MVAR\n')

A-20 20

f.write('De hasta\n') for k in range(0,nbr): i=int(nr[k])-1 j=int(nl[k])-1 f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %fqdi[k]+'\n') #print

#imprimiendo perdidas en las lineas f.write('\n') f.write('Perdidas potencia real MW\n') f.write('De hasta\n') for k in range(0,nbr): i=int(nr[k])-1 j=int(nl[k])-1 f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %ppr[k]+'\n') #print

#imprimiendo perdidas en las lineas f.write('\n') f.write('Perdidas potencia reactiva MVAR\n') f.write('De hasta\n') for k in range(0,nbr): i=int(nr[k])-1 j=int(nl[k])-1 f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %ppre[k]+'\n') #print return angesgr f.close()

def apertura(): import os print 'Abriendo reporte.....' archivo=os.popen('reporte'+str(nnbus)+'buses.txt')

21 A-21

22

ANEXO B
PROGRAMA DE FLUJO PTIMO DE POTENCIA (OPF) MODELO AC

23

24

from cvxopt import matrix, spmatrix, mul, div, sparse from math import atan, sin, cos, pi from scipy.linalg import inv from scipy import conjugate

def carga():#definiendo la funcin para cargar los datos del archivo de datos f = open('ac2.txt', 'r'); lines = f.readlines(); f.close() global MVA #leyendo los Mvar base del archivo de block de notas MVAB=lines[2].split() MVA=int(MVAB[0]) #leyendo los parmetros de buses ynames = lines[5].split() y = {} for name in ynames: y[name] = [] s=0 while s<1: for line in lines[6:]: yvalues = [float(yi) for yi in line.split()] if len(yvalues) == 0: break for name, value in zip(ynames, yvalues): y[name].append(value) s+=1 #leyendo los parmetros de lnea ul=8+len(y[name]) ul1=ul+1 ynames1 = lines[ul].split() y1 = {} for name1 in ynames1: y1[name1] = [] d=0 while d<1: for line in lines[ul1:]:

1 B-1

yvalues1 = [float(yi) for yi in line.split()] if len(yvalues1) == 0: break for name1, value1 in zip(ynames1, yvalues1): y1[name1].append(value1) d+=1 #leyendo los parmetros de lneas en paralelo ul2=11+len(y[name])+len(y1[name1]) ul3=ul2+1 ynames2 = lines[ul2].split() y2 = {} for name2 in ynames2: y2[name2] = [] e=0 while e<1: for line in lines[ul3:]: yvalues2 = [float(yi) for yi in line.split()] if len(yvalues2) == 0: break for name2, value2 in zip(ynames2, yvalues2): y2[name2].append(value2) e+=1 #leyendo los parmetros de transformadores de 2 devanados ul4=14+len(y[name])+len(y1[name1])+len(y2[name2]) ul5=ul4+1 ynames3 = lines[ul4].split() y3 = {} for name3 in ynames3: y3[name3] = [] f=0 while f<1: for line in lines[ul5:]: yvalues3 = [float(yi) for yi in line.split()] if len(yvalues3) == 0: break for name3, value3 in zip(ynames3, yvalues3): y3[name3].append(value3)

2 B-2

f+=1 #leyendo los parmetros de transformadores de 3 devanados ul6=17+len(y[name])+len(y1[name1])+len(y2[name2])+len(y3[name3]) ul7=ul6+1 ynames4 = lines[ul6].split() y4 = {} for name4 in ynames4: y4[name4] = [] g=0 while g<1: for line in lines[ul7:]: yvalues4 = [float(yi) for yi in line.split()] if len(yvalues4) == 0: break for name4, value4 in zip(ynames4, yvalues4): y4[name4].append(value4) g+=1

#generando matrices de datos global preacload,lr,preacgene,lam,prgene,prload,nbr4,nlt,nnbus,anges,tbus,V,nombus,pes,qes,nbr,nl,nr,R, x,lip,lsp,lipr,lspr,B,A,cf,cv,cc #datos de buses nnbus=len(y['nombre'])# numero de buses del sistema anges=matrix(y['rad'],(nnbus,1)) tbus=matrix(y['bus'],(nnbus,1))#bus PQ=0, bus PV=2, bus referencia=1 V=matrix(y['vol'],(nnbus,1)) nombus=matrix(y['nombre'],(nnbus,1)) prload=matrix(y['loadMW'],(nnbus,1)) preacload=matrix(y['loadMvar'],(nnbus,1)) prgene=matrix(y['generaMW'],(nnbus,1)) preacgene=matrix(y['generaMvar'],(nnbus,1)) lip=matrix(y['lpinf'],(nnbus,1)) lsp=matrix(y['lpsup'],(nnbus,1)) lipr=matrix(y['lprinf'],(nnbus,1)) lr=matrix(y['lreac'],(nnbus,1)) cf=matrix(y['a'],(nnbus,1)) cv=matrix(y['b'],(nnbus,1))

3 B-3

cc=matrix(y['c'],(nnbus,1)) lam=matrix(y['l'],(nnbus,1)) # parametros de las lineas

nbr1=len(y1['nl'])# numero de lneas del sistema nomlin=matrix(y1['nomlin'],(nbr1,1))#nombre de lnea nl1=matrix(y1['nl'],(nbr1,1))#lnea desde nr1=matrix(y1['nr'],(nbr1,1))#lnea hasta R1=matrix(y1['R'],(nbr1,1))# resistencia de lnea x1=matrix(y1['X'],(nbr1,1))#reactancia de lnea B1=matrix(y1['B'],(nbr1,1))#suceptancia de lnea A1=matrix(y1['a'],(nbr1,1))#lnea o transformador

#parmetros de lneas en paralelo nbr2=len(y2['nl1'])# numero de lneas en //del sistema nomlinp=matrix(y2['nlp'],(nbr2,1))#nombre de lnea // nlp1=matrix(y2['nl1'],(nbr2,1))#lnea desde nrp1=matrix(y2['nr1'],(nbr2,1))#lnea hasta Rp=matrix(y2['R1'],(nbr2,1))# resistencia de lnea xp=matrix(y2['X1'],(nbr2,1))#reactancia de lnea Bp=matrix(y2['B1'],(nbr2,1))#suceptancia de lnea lp=matrix(y2['a1'],(nbr2,1))

plpd=0 plph=0 cb=0 cdl=0 cp=0 if nbr2!=0: for k in range(0,nbr2-1):#conteo de cuantos bloques de lneas hay en // if nlp1[k]!=nlp1[k+1] or nrp1[k]!=nrp1[k+1]: cp+=1 cp=cp+1 lan=spmatrix([],[],[],(cp,1),tc='d') nlpf=spmatrix([],[],[],(cp,1),tc='d') nrpf=spmatrix([],[],[],(cp,1),tc='d') req=spmatrix([],[],[],(cp,1),tc='d')

4 B-4

xeq=spmatrix([],[],[],(cp,1),tc='d') beq=spmatrix([],[],[],(cp,1),tc='d') Ap=matrix(1,(cp,1),tc='d') if cp>1: j=spmatrix([],[],[],(cp+1,1),tc='d') if cp==1: j=spmatrix([],[],[],(cp,1),tc='d') for k in range(0,nbr2):# conteo de cuantas lneas hay en cada bloque lp[k]=nomlinp[k]-nbr1-1 if lp[k]==0: plpd=int(nlp1[k]) plph=int(nrp1[k]) nlpf[cb]=plpd nrpf[cb]=plph j[cb]=0 if lp[k]!=0: if nlp1[k]==plpd and nrp1[k]==plph: cdl+=1 else: plpd=int(nlp1[k]) plph=int(nrp1[k]) j[cb+1]=k nlpf[cb+1]=plpd nrpf[cb+1]=plph cdl+=1 lan[cb]=cdl cdl=0 cb+=1 if cp-1==cb and lp[k]==nbr2-1 and cp>1: cdl+=1 lan[cb]=cdl j[cb+1]=k if cp==1: cdl+=1 lan[cb]=cdl nlpf[cb]=plpd nrpf[cb]=plph

5 B-5

j[cb]=cdl #print j #calculo de los parmetros de las lneas en // if cp>1: for k in range(0,cp): if cp-1>k: for i in range(int(j[k]),int(j[k+1])): req[k]=req[k]+1/(Rp[i]) xeq[k]=xeq[k]+1/(xp[i]) beq[k]=beq[k]+1/(Bp[i]) req[k]=1/req[k] xeq[k]=1/xeq[k] beq[k]=1/beq[k] if cp-1==k: for i in range(int(j[k]),int(j[k+1])+1): req[k]=req[k]+1/(Rp[i]) xeq[k]=xeq[k]+1/(xp[i]) beq[k]=beq[k]+1/(Bp[i]) req[k]=1/req[k] xeq[k]=1/xeq[k] beq[k]=1/beq[k]

if cp==1: for k in range(0,cp): for i in range(0,int(j[k])): req[k]=req[k]+1/(Rp[i]) xeq[k]=xeq[k]+1/(xp[i]) beq[k]=beq[k]+1/(Bp[i]) req[k]=1/req[k] xeq[k]=1/xeq[k] beq[k]=1/beq[k] #print req #print plph #parmetros de transformadores de 2 devanados nbr3=len(y3['nl2t'])# numero de transformadores de 2 dev nomt2=matrix(y3['nomtransf2'],(nbr3,1))#nombre de transformador nlt2=matrix(y3['nl2t'],(nbr3,1))#desde

6 B-6

nrt2=matrix(y3['nr2t'],(nbr3,1))#hasta R2=matrix(y3['R2'],(nbr3,1))# resistencia x2=matrix(y3['X2'],(nbr3,1))#reactancia B2=matrix(y3['B2'],(nbr3,1))#susceptancia A2=matrix(y3['a2'],(nbr3,1))#relacin de transformacin

#parmetros de transformadores de 3 devanados nbr4=len(y4['nl3t'])# numero de transformadores de 3 devanados nomt3=matrix(y4['nomtransf3'],(nbr4,1))#nombre de transformador nlp2=matrix(y4['nl3t'],(nbr4,1))#desde np12=matrix(y4['nr3t1'],(nbr4,1))#hasta secundario np13=matrix(y4['nr3t2'],(nbr4,1))#hasta terciario rps=matrix(y4['R12'],(nbr4,1))# resistencia primario-secundario rpt=matrix(y4['R13'],(nbr4,1))# resistencia primario-terciario rst=matrix(y4['R23'],(nbr4,1))# resistencia secundario-terciario xps=matrix(y4['X12'],(nbr4,1))# reactancia primario-secundario xpt=matrix(y4['X13'],(nbr4,1))# reactancia primario-terciario xst=matrix(y4['X23'],(nbr4,1))# reactancia secundario-terciario bps=matrix(y4['B12'],(nbr4,1))# susceptancia primario-secundario bpt=matrix(y4['B13'],(nbr4,1))# susceptancia primario-terciario bst=matrix(y4['B23'],(nbr4,1))# susceptancia secundario-terciario A3=matrix(y4['a3'],(nbr4,1))#relacin de transformacin nc=matrix(y4['nc'],(nbr4,1))#nodo comn del transformador de tres devanados x31=spmatrix([],[],[],(nbr4,1),tc='d') x32=spmatrix([],[],[],(nbr4,1),tc='d') x33=spmatrix([],[],[],(nbr4,1),tc='d') x12=spmatrix([],[],[],(nbr4,1),tc='d') x13=spmatrix([],[],[],(nbr4,1),tc='d') r31=spmatrix([],[],[],(nbr4,1),tc='d') r32=spmatrix([],[],[],(nbr4,1),tc='d') r33=spmatrix([],[],[],(nbr4,1),tc='d') r12=spmatrix([],[],[],(nbr4,1),tc='d') r13=spmatrix([],[],[],(nbr4,1),tc='d') b31=spmatrix([],[],[],(nbr4,1),tc='d') b32=spmatrix([],[],[],(nbr4,1),tc='d') b33=spmatrix([],[],[],(nbr4,1),tc='d') b12=spmatrix([],[],[],(nbr4,1),tc='d')

7 B-7

b13=spmatrix([],[],[],(nbr4,1),tc='d') #baux=spmatrix([],[],[],(nbr4,1),tc='d') for k in range(0,nbr4): x31[k]=0.5*(xps[k]+xpt[k]-xst[k])#reactancia x32[k]=0.5*(xps[k]-xpt[k]+xst[k]) x33[k]=0.5*(-xps[k]+xpt[k]+xst[k]) x12[k]=x31[k]+x32[k] x13[k]=x31[k]+x33[k]

r31[k]=0.5*(rps[k]+rpt[k]-rst[k])#resistencia r32[k]=0.5*(rps[k]-rpt[k]+rst[k]) r33[k]=0.5*(-rps[k]+rpt[k]+rst[k]) r12[k]=r31[k]+r32[k] r13[k]=r31[k]+r33[k]

b31[k]=0.5*(bps[k]+bpt[k]-bst[k])#susceptancia b32[k]=0.5*(bps[k]-bpt[k]+bst[k]) b33[k]=0.5*(-bps[k]+bpt[k]+bst[k]) b12[k]=b31[k]+b32[k] b13[k]=b31[k]+b33[k] nbr=nbr1+cp+nbr3+3*nbr4

if nbr2!=0:# si hay lneas en // A=sparse([A1,Ap,A2,A3,1,1]) A=matrix(A) nlt=sparse([nomlin,nomlinp,nomt2,nomt3]) nlt=matrix(nlt) R=sparse([R1,req,R2,r31,r32,r33]) R=matrix(R) x=sparse([x1,xeq,x2,x31,x32,x33]) x=matrix(x) B=sparse([B1,beq,B2,b31,b32,b33]) B=matrix(B) nl=sparse([nl1,nlpf,nlt2,nlp2,nc,nc]) nl=matrix(nl) nr=sparse([nr1,nrpf,nrt2,nc,np12,np13]) nr=matrix(nr)

8 B-8

if nbr2==0:#si no hay lneas en // A=sparse([A1,A2,A3,1,1]) A=matrix(A) nlt=sparse([nomlin,nomt2,nomt3]) nlt=matrix(nlt) R=sparse([R1,R2,r31,r32,r33]) R=matrix(R) x=sparse([x1,x2,x31,x32,x33]) x=matrix(x) B=sparse([B1,B2,b31,b32,b33]) B=matrix(B) nl=sparse([nl1,nlt2,nlp2,nc,nc]) nl=matrix(nl) nr=sparse([nr1,nrt2,nc,np12,np13]) nr=matrix(nr)

#potencias en p.u pes=spmatrix([],[],[],(nnbus,1)) qes=spmatrix([],[],[],(nnbus,1)) for i in range(0,nnbus): # generando los valores de potencia en p.u pes[i]=(prgene[i]-prload[i])/MVA qes[i]=(preacgene[i]-preacload[i])/MVA

def ybus():# funcion que genera la matriz ybus global Ypa, Ypm, Y, bc,ds #matrices necesarias para armar la Ybus xc=spmatrix([],[],[],(nbr,1),tc='z') bc=spmatrix([],[],[],(nbr,1),tc='z') x1=spmatrix([],[],[],(nbr,1)) y1=spmatrix([],[],[],(nbr,1)) Y=spmatrix([],[],[],(nnbus,nnbus),tc='z') y=matrix(1,(nbr,1)) Ypr=spmatrix([],[],[],(nnbus,nnbus)) Ypi=spmatrix([],[],[],(nnbus,nnbus)) Ypm=spmatrix([],[],[],(nnbus,nnbus)) Ypa=spmatrix([],[],[],(nnbus,nnbus))

9 B-9

#iniciando la formacion de Ybus llamdo Y en rectangular int() s=0 cx=0 bx=0 while s<=nbr-1: int(x[s,0]) cx=matrix(x[s]*1j) xc[s,0]=cx int(B[s,0]) bx=matrix(B[s]*1j) bc[s,0]=bx s+=1 z=R+xc ds=div(y,z) #print ds # Ybus fuera de la diagonal for d in range(0,nbr): if nl[d] > 0 and nr[d] > 0: x0=int(nl[d])-1 y0=int(nr[d])-1 Y[x0,y0]=Y[x0,y0]-ds[d]/A[d] Y[y0,x0]=Y[x0,y0] # Ybus en la diagonal for n in range(0,nnbus): for k in range(0,nbr): x1[k]=int(nl[k])-1 y1[k]=int(nr[k])-1 if x1[k]==n: Y[n,n]=Y[n,n]+ ds[k]/(A[k]**2)+bc[k]/2 if y1[k]==n: Y[n,n]=Y[n,n]+ ds[k]+bc[k]/2

#pasando Ybus de rectangular a polar for n in range(0,nnbus): for k in range(0,nnbus): Ypr[n,k]=Y[n,k].real

10 B-10

Ypi[n,k]=Y[n,k].imag Ypm[n,k]=abs(Y[n,k]) # magnitud de Ybus if Ypr[n,k] > 0 or Ypr[n,k] < 0: if n==k: Ypa[n,k]=atan(Ypi[n,k]/Ypr[n,k]) # angulo de Ybus en la diagonal if n<k or n>k: Ypa[n,k]=atan(Ypi[n,k]/Ypr[n,k])+pi # angulo de Ybus fuera de la diagonal if Ypr[n,k]==0 and Ypi[n,k]>0: Ypa[n,k]=pi/2 if Ypr[n,k]==0 and Ypi[n,k]<0: Ypa[n,k]=-pi/2 return Y

def cpo():#funcion que genera lamda global lini, angi, Vi, fprlin, fpreaclin, lamdas, cost

lini=spmatrix([],[],[],(nnbus,1),tc='d') ppcal=spmatrix([],[],[],(nnbus,1),tc='d') Vi=spmatrix([],[],[],(nnbus,1),tc='d') angi=spmatrix([],[],[],(nnbus,1),tc='d') lamdas=spmatrix([],[],[],(2*nnbus,1),tc='d') bgene=0 for i in range(0,nnbus): Vi[i-1]=V[i]#voltaje inicial angi[i]=anges[i]#angulo inicial if cc[i]>0: bgene+=1 dx=4*bgene+4*(nnbus-1) busgene=spmatrix([],[],[],(bgene,1)) dlpg=spmatrix([],[],[],(nnbus,1)) dlt=spmatrix([],[],[],(nbr,1)) dll=spmatrix([],[],[],(nnbus,1)) busl=spmatrix([],[],[],(nnbus-bgene,1)) hes=matrix(0,(dx,dx),tc='d') hesin=spmatrix([],[],[],(dx,dx)) grad=spmatrix([],[],[],(dx,1)) pig=spmatrix([],[],[],(bgene,1))

11 B-11

xnueva=spmatrix([],[],[],(dx,1),tc='d') a=0 for i in range(0,nnbus): if cv[i]>0: busgene[a]=nombus[i] a+=1 b=0 for i in range(0,nnbus): if cv[i]==0: busl[b]=nombus[i] b+=1 c=0 for i in range(0,nnbus): if cv[i]>0: pig[c]=prgene[int(busgene[c])-1] c+=1 for i in range(0,nnbus-1): y=sparse([angi[i+1],Vi[i+1],prgene[i],preacgene[i],lam,lr])# matriz de incognitas iniciales #print y

it=0#variable numero de iteraciones er = 0.00001 #detener el programa si ya se alcanzo la tolerancia dip=5 diq=5 p12=0 p21=0 q12=0 q21=0 gam=0 bet=0 while (dip and diq) > er and it<=100:

for k in range(0,1): if k==0: p21=Vi[k+1]*Vi[k+1]*Ypm[k,k]*cos(Ypa[k,k])-Vi[k]*Vi[k+1]*Ypm[k,k]*cos(angi[k]+Ypa[k,k] -angi[k+1])

12 B-12

p12=Vi[k]*Vi[k]*Ypm[k,k]*cos(Ypa[k,k])-Vi[k]*Vi[k+1]*Ypm[k,k]*cos(angi[k+1]+Ypa[k,k] -angi[k]) q21=Vi[k+1]*Vi[k+1]*Ypm[k,k]*sin(Ypa[k,k])-Vi[k]*Vi[k+1]*Ypm[k,k]*sin(angi[k]+Ypa[k,k] -angi[k+1]) q12=Vi[k]*Vi[k]*Ypm[k,k]*sin(Ypa[k,k])-Vi[k]*Vi[k+1]*Ypm[k,k]*sin(angi[k+1]+Ypa[k,k] - angi[k]) grad[k]=Vi[k]*Vi[k+1]*Ypm[k,k]*(lam[k]*sin(angi[k+1]+Ypa[k,k]-angi[k]) - lam[k+1]*sin(angi[k]+Ypa[k,k]-angi[k+1])-lr[k]*cos(angi[k+1]+Ypa[k,k] -angi[k])+lr[k+1]*cos(angi[k]+Ypa[k,k]-angi[k+1])) grad[k+1]=-lam[k]*Vi[k]*Ypm[k,k]*cos(angi[k+1]+Ypa[k,k]-angi[k])+lam[k+1]*(2*Vi[k+1]*Ypm[k,k]*cos(Ypa[k,k]) -Vi[k]*Ypm[k,k]*cos(angi[k]+Ypa[k,k] - angi[k+1]))-lr[k]*Vi[k]*Ypm[k,k]*sin(angi[k+1]+Ypa[k,k] - angi[k])+lr[k+1]*Ypm[k,k]*(2*Vi[k+1]*sin(Ypa[k,k])-Vi[k]*sin(angi[k]+Ypa[k,k] -angi[k+1])) grad[k+2]=cv[k]+2*cc[k]*prgene[k]-lam[k]/MVA grad[k+3]=-lr[k]/MVA grad[k+4]=prload[k]/MVA+p12-prgene[k]/MVA grad[k+5]=prload[k+1]/MVA+p21 grad[k+6]=preacload[k]/MVA+q12-preacgene[k]/MVA grad[k+7]=preacload[k+1]/MVA+q21

for k in range(0,1): for j in range(0,1): if j==0: gam=angi[j+1]+Ypa[j]-angi[j] bet=angi[j]+Ypa[j]-angi[j+1] if k==0: hes[k,k]=Vi[k]*Vi[k+1]*Ypm[k,k]*(lam[k]*cos(gam)+lam[k+1]*cos(bet)+lr[k]*sin(gam) +lr[k+1]*sin(bet)) hes[k+1,j]=Vi[k]*Ypm[k,k]*(lam[k]*sin(gam)-lam[k+1]*sin(gam) - lr[k]*cos(gam)+lr[k+1]*cos(bet)) hes[k+4,j]=Vi[k]*Vi[k+1]*Ypm[k,k]*sin(gam) hes[k+5,j]=-Vi[k]*Vi[k+1]*Ypm[k,k]*sin(bet) hes[k+6,j]=-Vi[k]*Vi[k+1]*Ypm[k,k]*cos(gam) hes[k+7,j]=Vi[k]*Vi[k+1]*Ypm[k,k]*cos(bet)

13 B-13

hes[k,j+1]=Vi[k]*Ypm[k,k]*(lam[k]*sin(gam)-lam[k+1]*sin(bet) -lr[k]*cos(gam)+lr[k+1]*cos(bet)) hes[k+1,j+1]=2*Ypm[k,k]*(lam[k+1]*cos(Ypa[k])+lr[k+1]*sin(Ypa[k])) hes[k+4,j+1]=-Vi[k]*Ypm[k,k]*cos(gam) hes[k+5,j+1]=2*Vi[k+1]*Ypm[k,k]*cos(Ypa[k])-Vi[k]*Ypm[k,k]*cos(bet) hes[k+6,j+1]=-Vi[k]*Ypm[k,k]*sin(gam) hes[k+7,j+1]=2*Vi[k+1]*Ypm[k,k]*sin(Ypa[k])-Vi[k]*Ypm[k,k]*sin(bet) hes[k+2,j+2]=2*cc[k] hes[k+4,j+2]=-1./MVA hes[k+6,j+3]=-1./MVA hes[k,j+4]=-Vi[k]*Vi[k+1]*Ypm[k,k]*sin(gam) hes[k+1,j+4]=-Vi[k]*Ypm[k,k]*cos(gam) hes[k+2,j+4]=-1./MVA hes[k,j+5]=-Vi[k]*Vi[k+1]*Ypm[k,k]*sin(bet) hes[k+1,j+5]=2*Vi[k+1]*Ypm[k,k]*cos(Ypa[k])-Vi[k]*Ypm[k,k]*cos(bet) hes[k,j+6]=-Vi[k]*Vi[k+1]*Ypm[k,k]*cos(gam) hes[k+1,j+6]=-Vi[k]*Ypm[k,k]*sin(gam) hes[k+3,j+6]=-1./MVA hes[k,j+7]=Vi[k]*Vi[k+1]*Ypm[k,k]*cos(bet) hes[k+1,j+7]=2*Vi[k+1]*Ypm[k,k]*sin(Ypa[k])-Vi[k]*Ypm[k,k]*sin(bet) hesin=inv(hes) hesin=matrix(hesin,(dx,dx)) deltax= mul(hesin*grad) hesin=spmatrix([],[],[],(dx,dx)) hes=matrix(0,(dx,dx),tc='d') for k in range(0,dx): xnueva[k]=y[k]-deltax[k]

for k in range(0,dx): if k==0: angi[k+1]=xnueva[k] y[k]=xnueva[k] if k==1: Vi[k]=xnueva[k] y[k]=xnueva[k] if k==2: prgene[k-2]=xnueva[k]

14 B-14

y[k]=xnueva[k] if k==3: preacgene[k-3]=xnueva[k] y[k]=xnueva[k] if k==4 or k==5: lam[k-4]=xnueva[k] y[k]=xnueva[k] if k==6 or k==7: lr[k-6]=xnueva[k] y[k]=xnueva[k]

dip=max(abs(deltax)) diq=max(abs(deltax)) it+=1 #print it for k in range(0,nnbus): anges[k]=angi[k]

cost=0 for k in range(0,2): cost=cost+cf[k]+cv[k]*prgene[k]+cc[k]*prgene[k]**2 for k in range(0,2*nnbus): if k<nnbus: lamdas[k]=lam[k] if k>=nnbus: lamdas[k]=lr[k-nnbus] fprlin=spmatrix([],[],[],(nbr,1),tc='d') fpreaclin=spmatrix([],[],[],(nbr,1),tc='d') #calculo flujos de potencia real en lineas for k in range(0,nbr): i=int(nl[k])-1 j=int(nr[k])-1 fprlin[k]=-Vi[i]**2*Ypm[i,j]*cos(Ypa[i,j])+Vi[i]*Vi[j]*Ypm[i,j]*cos(Ypa[i,j]+anges[j]-anges[i]) fpreaclin[k]=-Vi[i]**2*Ypm[i,j]*sin(Ypa[i,j])+Vi[i]*Vi[j]*Ypm[i,j]*sin(Ypa[i,j]+anges[j]-anges[i])

def salida():#funcion que genera el reporte global angesgr

15 B-15

angesgr=spmatrix([],[],[],(nnbus,1)) for i in range(0,nnbus): angesgr[i]=angi[i]*180/pi f = open('reporteOPFAC'+str(nnbus)+'buses.txt', 'w') format = "%.3f" # imprimiendo voltajes de nodo f.write('Magnitud de voltaje\n') f.write('Bus pu\n') for k in range(0,nnbus): f.write(str(k+1)+' '+format %Vi[k]+'\n')

#print 'Magnitud de voltaje en pu' #print Vi # imprimiendo angulos de nodo f.write('\n') f.write('Angulo\n') f.write('Bus grados\n') for k in range(0,nnbus): f.write(str(k+1)+' '+format %angesgr[k]+'\n')

#print 'Angulo en grados' #print angesgr # imprimiendo flujo potencia activa en las lineas f.write('\n') f.write('Potencia activa en lineas MW\n') f.write('De hasta\n') #print 'Potencia real en MW' for k in range(0,nbr): i=int(nl[k])-1 j=int(nr[k])-1 fprlin[k]=fprlin[k]*MVA f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %fprlin[k]+'\n') #print 'Flujo en lineas en MW' #print fprlin # imprimiendo flujo potencia reactiva en las lineas f.write('\n') f.write('Potencia reactiva en lineas MVAR\n') f.write('De hasta\n')

16 B-16

#print 'Potencia real en MW' for k in range(0,nbr): i=int(nl[k])-1 j=int(nr[k])-1 fpreaclin[k]=fpreaclin[k]*MVA f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %fpreaclin[k]+'\n') #print 'Flujo en lineas en MVAR' #print fpreaclin # imprimiendo potencia activa generada NODAL f.write('\n') f.write('Potencia activa generada en MW\n') f.write('Bus\n') for k in range(0,nnbus): f.write(str(k+1)+' ') f.write(format %prgene[k]+'\n') #print 'Potencia activa generada en MW' #print prgene # imprimiendo potencia reactiva generada NODAL f.write('\n') f.write('Potencia reactiva generada en MVAR\n') f.write('Bus\n') for k in range(0,nnbus): f.write(str(k+1)+' ') f.write(format %preacgene[k]+'\n') #print 'Potencia reactiva generada en MVAR' #print preacgene #imprimiendo costos NODALES por POTENCIA ACTIVA f.write('\n') f.write('Costo marginal $/MWh\n') f.write('Bus\n') for k in range(0,nnbus): f.write(str(k+1)+' ') lamdas[k]=lamdas[k]/MVA f.write(format %lamdas[k]+'\n') #print 'Costo marginal $/MWh' #for k in range(0,nnbus):

17 B-17

#print format %lamdas[k] #print #imprimiendo costos NODALES por REACTIVOS f.write('\n') f.write('Costo marginal $/MVARh\n') f.write('Bus\n') for k in range(nnbus,2*nnbus): f.write(str(k+1-nnbus)+' ') lamdas[k]=lamdas[k]/MVA f.write(format %lamdas[k]+'\n') #print 'Costo marginal $/MVARh' #for k in range(nnbus,2*nnbus): #print format %lamdas[k] f.write('\n') #imprimiendo costo TOTAL f.write('Costo Total=$'+format %cost) #print #print "Costo Total=\n","$",format %cost,"\n" return angesgr f.close()

def apertura(): import os print 'Abriendo reporte.....' archivo=os.popen('reporteOPFAC'+str(nnbus)+'buses.txt')

18 B-18

ANEXO C
PROGRAMA DE FLUJO PTIMO DE POTENCIA (OPF) MODELO DC

from cvxopt import matrix, spmatrix, mul, div, sparse from math import atan, sin, cos, pi from scipy.linalg import inv from scipy import conjugate def carga():#definiendo la funcion para cargar los datos del archivo de datos f = open('dc3.txt', 'r'); lines = f.readlines(); f.close() global MVA #leyendo MVA base del archivo MVAB=lines[2].split() MVA=int(MVAB[0]) #leyendo parametros de buses ynames = lines[5].split() y = {} for name in ynames: y[name] = [] s=0 while s<1: for line in lines[6:]: yvalues = [float(yi) for yi in line.split()] if len(yvalues) == 0: break for name, value in zip(ynames, yvalues): y[name].append(value) s+=1 #leyendo parametros de linea ul=8+len(y[name]) ul1=ul+1 ynames1 = lines[ul].split() y1 = {} for name1 in ynames1: y1[name1] = [] d=0 while d<1: for line in lines[ul1:]: yvalues1 = [float(yi) for yi in line.split()]

1 C-1

if len(yvalues1) == 0: break for name1, value1 in zip(ynames1, yvalues1): y1[name1].append(value1) d+=1

#generando matrices de datos global nl1,nr1,lam,prgene,prload,nbr1,nlt,nnbus,anges,tbus,V,nombus,pes,qes,R,x,lip,lsp,lipr,lspr B,A,cf,cv,cc #datos de buses nnbus=len(y['nombre'])# numero de buses del sistema anges=matrix(y['rad'],(nnbus,1)) tbus=matrix(y['bus'],(nnbus,1))#bus PQ=0, bus PV=2, bus referencia=1 V=matrix(y['vol'],(nnbus,1)) nombus=matrix(y['nombre'],(nnbus,1)) prload=matrix(y['loadMW'],(nnbus,1)) preacload=matrix(y['loadMvar'],(nnbus,1)) prgene=matrix(y['generaMW'],(nnbus,1)) preacgene=matrix(y['generaMvar'],(nnbus,1)) lip=matrix(y['lpinf'],(nnbus,1)) lsp=matrix(y['lpsup'],(nnbus,1)) lipr=matrix(y['lprinf'],(nnbus,1)) lspr=matrix(y['lprsup'],(nnbus,1)) cf=matrix(y['a'],(nnbus,1)) cv=matrix(y['b'],(nnbus,1)) cc=matrix(y['c'],(nnbus,1)) lam=matrix(y['l'],(nnbus,1))

# parametros de las lineas nbr1=len(y1['nl'])# numero de lineas del sistema nomlin=matrix(y1['nomlin'],(nbr1,1))#nombre de linea nl1=matrix(y1['nl'],(nbr1,1))#linea desde nr1=matrix(y1['nr'],(nbr1,1))#linea hasta R1=matrix(y1['R'],(nbr1,1))# resitencia de linea x=matrix(y1['X'],(nbr1,1))#reactancia de linea B=matrix(y1['B'],(nbr1,1))#suceptancia de linea A=matrix(y1['a'],(nbr1,1))#linea o tranformador

2 C-2

#calculando potencias limites en p.u for i in range(0,nnbus): lip[i]=lip[i]/MVA lsp[i]=lsp[i]/MVA lipr[i]=lipr[i]/MVA lspr[i]=lspr[i]/MVA #potencias en p.u pes=spmatrix([],[],[],(nnbus,1)) qes=spmatrix([],[],[],(nnbus,1)) for i in range(0,nnbus): # generando los valores de potencia en p.u pes[i]=(prgene[i]-prload[i])/MVA qes[i]=(preacgene[i]-preacload[i])/MVA

def cpo():#funcion que genera lamda global lini,ds, cost, lam, fplin

lini=spmatrix([],[],[],(nnbus,1),tc='d') ppcal=spmatrix([],[],[],(nnbus,1),tc='d') Vi=spmatrix([],[],[],(nnbus-1,1),tc='d') angi=spmatrix([],[],[],(nnbus-1,1),tc='d')

bgene=0 for i in range(0,nnbus): if i>0: Vi[i-1]=V[i]#voltaje inicial angi[i-1]=anges[i]#angulo inicial if cv[i]>0: bgene+=1 dx=bgene+2*nnbus-1 busgene=spmatrix([],[],[],(bgene,1)) dlpg=spmatrix([],[],[],(nnbus,1)) dlt=spmatrix([],[],[],(nbr1,1)) dll=spmatrix([],[],[],(nnbus,1)) busl=spmatrix([],[],[],(nnbus-bgene,1)) hes=matrix(0,(dx,dx),tc='d')

3 C-3

hesin=spmatrix([],[],[],(dx,dx)) grad=spmatrix([],[],[],(dx,1)) pig=spmatrix([],[],[],(bgene,1)) xn=spmatrix([],[],[],(dx,1),tc='d') CV=spmatrix([],[],[],(bgene,1)) CC=spmatrix([],[],[],(bgene,1)) LAM=spmatrix([],[],[],(bgene,1)) a=0 for i in range(0,nnbus): if cv[i]>0: busgene[a]=nombus[i] a+=1 b=0 for i in range(0,nnbus): if cv[i]==0: busl[b]=nombus[i] b+=1 c=0 for i in range(0,nnbus): lini[i]=lam[i] if cv[i]>0: pig[c]=prgene[int(busgene[c])-1] CV[c]=cv[int(busgene[c])-1] CC[c]=cc[int(busgene[c])-1] c+=1

dpr=spmatrix([],[],[],(bgene,1),tc='d') dtas=spmatrix([],[],[],(nnbus-1,1),tc='d') dlam=spmatrix([],[],[],(nnbus,1),tc='d') Y=spmatrix([],[],[],(nnbus,nnbus),tc='d') y=matrix(1,(nbr1,1)) x1=spmatrix([],[],[],(nbr1,1)) y1=spmatrix([],[],[],(nbr1,1))

ds=div(y,x) # Ybus fuera de la diagonal for d in range(0,nbr1):

4 C-4

if nl1[d] > 0 and nr1[d] > 0: x0=int(nl1[d])-1 y0=int(nr1[d])-1 Y[x0,y0]=Y[x0,y0]-ds[d] Y[y0,x0]=Y[x0,y0] # Ybus en la diagonal for n in range(0,nnbus): for k in range(0,nbr1): x1[k]=int(nl1[k])-1 y1[k]=int(nr1[k])-1 if x1[k]==n: Y[n,n]=Y[n,n]+ ds[k] if y1[k]==n: Y[n,n]=Y[n,n]+ ds[k]

#generando la matriz Hessiana MCC=spmatrix([],[],[],(nnbus,nnbus),tc='d') MIMVA=spmatrix([],[],[],(nnbus,nnbus),tc='d') MZERO=spmatrix([],[],[],(nnbus,nnbus),tc='d') MZERO1=spmatrix([],[],[],(nnbus,nnbus-1),tc='d') MZERO2=spmatrix([],[],[],(nnbus-1,nnbus-1),tc='d') MZERO3=spmatrix([],[],[],(nnbus-1,nnbus),tc='d') Y1=spmatrix([],[],[],(nnbus-1,nnbus),tc='d') Y2=spmatrix([],[],[],(nnbus,nnbus-1),tc='d') hes3=spmatrix([],[],[],(3*nnbus-1,bgene)) hes=matrix(0,(dx,dx),tc='d') for i in range(0,nnbus): MCC[i,i]=2*cc[i] MIMVA[i,i]=-1./MVA

for i in range(1,nnbus): for j in range(0,nnbus): Y1[i-1,j]=Y[i,j]

for i in range(0,nnbus): for j in range(1,nnbus): Y2[i,j-1]=Y[i,j]

5 C-5

hes0=matrix([MCC,MZERO3,MIMVA]) hes1=matrix([MZERO1,MZERO2,Y2]) hes2=matrix([MIMVA,Y1,MZERO]) hes5=matrix([[MCC],[MZERO1],[MIMVA]]) hes8=matrix([[hes0],[hes1],[hes2]]) for i in range(0,bgene): for j in range(0,3*nnbus-1): k=int(busgene[i])-1 hes3[j,i]=hes0[j,k]

hes4=matrix([[hes3],[hes1],[hes2]]) for i in range(0,bgene): for j in range(0,dx): k=int(busgene[i])-1 hes[i,j]=hes4[k,j] nbng=nnbus-bgene for i in range(bgene,dx): for j in range(0,dx): hes[i,j]=hes4[i+nbng,j]

hesin=inv(hes) hesinv=matrix(hesin,(dx,dx))

it=0#variable numero de iteraciones er = 0.0001 #detener el programa si ya se alcanzo la tolerancia dip=5 diq=5

while (dip and diq) > er and it<=100: c=0 for i in range(0,nnbus): if cv[i]>0: LAM[c]=lam[int(busgene[c])-1] c+=1

C-6 6

#Generando la matriz GRADIENTE xv=sparse([pig,angi,lam])# matriz de incognitas iniciales admsum=spmatrix([],[],[],(nnbus,1),tc='d') rangi=spmatrix([],[],[],(nnbus,nnbus),tc='d') rang=spmatrix([],[],[],(nnbus,1),tc='d') for i in range(0,bgene): dpr[i]=CV[i]+2*CC[i]*pig[i]-LAM[i]/MVA

for i in range(0,nnbus): for j in range(0,nnbus): admsum[i]=admsum[i]+lam[j]*Y[i,j]

for i in range(1,nnbus): dtas[i-1]=admsum[i] #obteniendo derivadas respecto a lamdas # Resta de Angulos fuera de la diagonal for d in range(0,nbr1): if nl1[d] > 0 and nr1[d] > 0: x0=int(nl1[d])-1 y0=int(nr1[d])-1 rangi[x0,y0]=rangi[x0,y0]+anges[x0]-anges[y0] rangi[y0,x0]=-rangi[x0,y0] drl=mul(rangi,Y)

for i in range(0,nnbus): for j in range(0,nnbus): rang[i]=rang[i]-drl[i,j]

for i in range(0,nnbus): dlam[i]=prload[i]/MVA-prgene[i]/MVA+rang[i]

grad=matrix([dpr,dtas,dlam]) deltax= mul(hesinv*grad)

for k in range(0,dx): xn[k]=xv[k]-deltax[k] for k in range(0,bgene):

7 C-7

pig[k]=xn[k]

for k in range(0,nnbus-1): angi[k]=xn[k+bgene] for k in range(0,nnbus): lam[k]=xn[k+bgene+nnbus-1] for i in range(0,bgene): k=int(busgene[i])-1 LAM[i]=lam[k] for k in range(1,nnbus): anges[k]=angi[k-1] for i in range(0,bgene): k=int(busgene[i])-1 prgene[k]=pig[i] dip=max(abs(deltax)) diq=max(abs(deltax)) it+=1 cost=0 for k in range(0,nnbus): cost=cost+cf[k]+cv[k]*prgene[k]+cc[k]*prgene[k]**2

fplin=spmatrix([],[],[],(nbr1,1),tc='d') #calculo flujos de potencia real en lineas for k in range(0,nbr1): i=int(nl1[k])-1 j=int(nr1[k])-1 fplin[k]=(anges[i]-anges[j])*Y[i,j]*(-1)*MVA

def salida():#funcion que genera el reporte global angesgr angesgr=spmatrix([],[],[],(nnbus,1)) for i in range(0,nnbus): angesgr[i]=anges[i]*180/pi f = open('reporteOPF'+str(nnbus)+'buses.txt', 'w') format = "%.3f" # imprimiendo voltajes de nodo

8 C-8

f.write('Magnitud de voltaje\n') f.write('Bus pu\n') for k in range(0,nnbus): f.write(str(k+1)+' '+format %V[k]+'\n')

#print 'Magnitud de voltaje en pu' #print V # imprimiendo angulos de nodo f.write('\n') f.write('Angulo\n') f.write('Bus grados\n') for k in range(0,nnbus): f.write(str(k+1)+' '+format %angesgr[k]+'\n')

#print 'Angulo en grados' #print angesgr # imprimiendo flujo en las lineas f.write('\n') f.write('Potencia real en lineas MW\n') f.write('De hasta\n') #print 'Potencia real en MW' for k in range(0,nbr1): i=int(nl1[k])-1 j=int(nr1[k])-1 f.write(str(i+1)+' '+str(j+1)+' ')

f.write(format %fplin[k]+'\n') #print 'Flujo en lineas en MW' #print fplin # imprimiendo pptencia generada NODAL f.write('\n') f.write('Potencia generada en MWh\n') f.write('Bus\n') for k in range(0,nnbus): f.write(str(k+1)+' ') f.write(format %prgene[k]+'\n') #print 'Potencia generada en MWh' #print prgene #imprimiendo costos NODALES f.write('\n')

9 C-9

f.write('Costo marginal $/MWh\n') f.write('Bus\n') for k in range(0,nnbus): f.write(str(k+1)+' ') lam[k]=lam[k]/MVA f.write(format %lam[k]+'\n') #print 'Costo marginal $/MWh' #print lam f.write('\n') #imprimiendo costo TOTAL f.write('Costo Total=$'+format %cost) #print "Costo Total=\n","$",format %cost,"\n" return angesgr f.close()

def apertura(): import os print 'Abriendo reporte.....' archivo=os.popen('reporteOPF'+str(nnbus)+'buses.txt')

10 C-10