Notación¶

En este documento se hace uso extensivo de operaciones matriciales y vectoriales. Por ello es importante definir de forma clara la notación que se va a seguir.

• \([A] \times [B] \rightarrow\) Multiplicación matricial. El resultado es una matriz.
• \([A] \times [b] \rightarrow\) Multiplicación Matriz-Vector. El resultado es un vector.
• \([a] \times [b]^\top \rightarrow\) Multiplicación Vector-Vector. El resultado es un escalar.
• \([A] \cdot [B] \rightarrow\) Multiplicación matricial elemento a elemento. A y B deben ser de las mismas dimensiones. El resultado es una matriz.
• \([a] \cdot [b] \rightarrow\) Multiplicación de vectores elemento a elemento. Los vectores deben tener las mismas dimensiones. El resultado es un vector.
• \([A]^{*}\rightarrow\) Conjugado de [A]. Se realiza el conjugado de todos los elementos individualmente.
• \([A]^{-1}\rightarrow\) Inversa de la matriz.
• \([A]^{\top}\rightarrow\) Transpuesta de la matriz o vector.
• \([A]^{-1} \times [b] \rightarrow\) Resolver el sistema de ecuaciones lineal descrito por la matriz de coeficientes [A] y el vector de términos independientes [b]. Nunca se ha de realizar la inversa de [A] para luego multiplicar la inversa por [b]. En su lugar, usar la factorización LU, QR o similar.
• \([A]_{(rows, :)} \rightarrow\) De la matriz [A], tomar las filas dadas por los valores del vector rows.
• \([A]_{(:, cols)} \rightarrow\) De la matriz [A], tomar las columnas dadas por los valores del vector cols.

• \([A]_{(rows, cols)} \rightarrow\) De la matriz [A], tomar las filas dadas por los valores del vector rows y

  las columnas dadas por el vector cols.

• \([b]_{(rows)} \rightarrow\) Del vector [b], tomar los elementos en las posiciones indicadas por el vector rows.
• \(diag([b]) \rightarrow\) Convertir el vector`[b]` en una matriz diagonal.
• \(diag([A]) \rightarrow\) Extraer la diagonal de la matriz [A] como un vector.
• \(Re\{ [A] \} \rightarrow\) Extraer la parte real [A] si es de tipo complejo.
• \(Im \{ [A] \} \rightarrow\) Extraer la parte imaginaria [A] si es de tipo complejo.
• \(max([b]) \rightarrow\) Máximo valor del vector [b].
• \(max(c, d) \rightarrow\) Tomar el mayor valor entre c y d.
• \([1] \rightarrow\) Matriz con unos en todas las posiciones.
• \([0] \rightarrow\) Matriz con cero en todas las posiciones.
• \([Idn] \rightarrow\) Matriz indentidad (Aquella con unos en la diagonal y ceros en el resto).

Supuesto de red equilibrada¶

Un supuesto habitual en ingeniería eléctrica, es asumir que las redes trifásicas están equilibradas. Una red equilibrada implica que cada una de las tres fases, lleva la misma cantidad de potencia. Este supuesto es siempre falso, aunque unas veces es más falso que otras. En las redes de transporte el supuesto es asumible.

En las redes de distribución modernas (España, Francia, Holanda, Alemania) el supuesto es asumible de forma general. Sin embargo, en las redes de distribución de países muy extensos como EEUU y Brasil, las redes de distribución son estructuralmente desequilibradas al contener ramales monofásicos o bifásicos. Por tanto, el supuesto de red equilibrada no es sostenible.

El sistema por unidad¶

En la red hay varios niveles de tensión, esto hace especialmente ineficiente el cálculo numérico. Por ello los ingenieros eléctricos usan una forma de hacer que todas las tensiones de la red se expresasen en términos de las tensiones nominales de los terminales de los componentes. Esto es lo mismo que decir que se hace una normalización de las variables. Esta normalización de las variables “suaviza” las diferencias numéricas a la hora de calcular y hace factible el cálculo numérico. Para pasar a valores por unidad, hay que elegir una potencia base. Normalmente se elige 100 MVA.

Para simplificar los cálculos y evitar confusiones, a efectos de cálculo las unidades deben ser las unidades recomendadas, indicadas en la tabla unidades.

Para pasar cualquier unidad a valores normalizados, se divide el valor entre su base.

Ejemplo de una línea:

Datos:

Impedancia

Potencia base del circuito

Tensión nominal de la línea

Cálculos:

Impedancia base

Impedancia por unidad

Transformaciones Estrella-Triangulo¶

A efectos de cálculo todos los elementos conectados a un nudo (cargas y generadores), han de estar en estrella. Sin embargo, en la realidad hay elementos conectados en delta y en estrella, por tanto, los elementos conectado en delta se han de pasar a estrella.

Las tensiones fase-fase de la conexión en Delta se denominan tensiones de línea (\(V_{AB}\), \(V_{AC}\), \(V_{BC}\)). Las tensiones fase-neutro de la conexión en estrella se denominan tensiones de fase (\(V_A\), \(V_B\), \(V_C\)).

Podemos definir la matriz D de transformación de estrella a triangulo como:

La matriz de transformación inversa (de triangulo a estrella) es:

\(D^{-1}\) es la pseudoinversa de D, puesto que D es singular. La implicación práctica es que una conversión estrella-triangulo no se puede deshacer a menos que el triángulo sea equilátero (con el neutro en el centroide).

Redes de secuencia¶

Charles L. Fortescue presenta en 1918 su artículo [1] en el que describe cómo expresar una red trifásica en componentes simétricas. Esto significa que, si tenemos una red trifásica en la que los tres cables son iguales y sus distancias son simétricas, podemos representar las impedancias de esos tres cables como otras tres impedancias equivalentes, de las cuales usaremos una o dos para calcular. Esto representó un gran avance en el cálculo permitiendo la representación “unifilar” de la red.

El uso más relevante de la reducción en componentes de secuencia es el uso de la secuencia positiva (i.e. \(Z_1\))

para los cálculos de flujo de potencia, estimación de estado, etc.

Fortescue define dos matrices de transformación:

Dónde \(a =e^{j 2/3 \pi}= 1^{120 deg}\) y \(a^2=e^{-j 2/3 \pi}=1^{-120 deg}\) son vectores unitarios de transformación en coordenadas polares. Entonces se plantea que cualquier matriz de impedancia de 3x3 en componentes de fase (ABC), se puede expresar en componentes de secuencia de acuerdo a la ecuación:

El circuito como gestor de activos¶

En este documento se presenta un arreglo de la información de la red que resuta ser eficiente y mantenible para su implementación en un programa de ordenador. El concepto principal es la agregación de los dispositivos de acuerdo a su agregación natural. Es decir, si una carga se modela conectada a un bus, es natural que en el bus haya una lista con las cargas conectadas, en lugar de que ambos dispositivos se almacenen de forma independiente. Esta agregación hace que añadir y borrar elementos sea muy sencillo. Además el procesado y acceso a la información se produce de forma inmediata.

Los conceptos son los siguientes:

• El circuito es el gestor de activos principal. Es la «caja» dónde se encuentra todo.
• El circuito sólo almacena buses y ramas.
• Los dispositivos de inyeccion tales como generadores y cargas se almacenan dentro del bus al que están conectados.
• Los interruptores se almacenan dentro de la rama a la que afectan.

El la sección «Compilando la información del gestor de activos» vemos cómo se convierte la información del gestor de activos, a vectores y matrices que están preparadas para el cálculo.

Ecuación del sistema¶

La ecuación que relaciona las cargas con las tensiones en estado estacionario es la siguiente:

La influencia de cada dispositivo sobre la ecuación es tal que las cargas tipo ZIP afectan al vector de potencia compleja \(S\), el vector de correinte compleja \(I\), y la diagonal de la matriz de admitancia \(Y\). Los generadores controlados afectan a la potencia real \(P\), y el módulo de la tensión \(|V|\). Las baterías se consideran igual que generadores de tensión controlada. Los elementos shunt, afectan a la diagonal de la matriz de admitancia \(Y\). Las ramas generales componen la matriz de admitancia \(Y\).

Bus¶

El bus es el lugar topológico de conexión de los elementos de la red eléctrica. Tal como se propuso en El circuito como gestor de activos, el Bus es un contenedor para los elementos de generación y carga de la red.

Modelo general de rama (Pi)¶

A efectos de la mayoría de cálculos en estado estacionario, los elementos rama de la red se representan con el denominado modelo \(\Pi\) (Pi). Para cálculos en régimen estacionario, casi cualquier elemento que conecte dos nudos de la red se puede representar con el denominado modelo \(\Pi\).

En el modelo pi, usa una admitancia serie () para representar la caída de tensión debida a la resistencia e inductancia de los cables y una admitancia de acoplamiento con el suelo () que se divide en dos admitancias conectadas a cada nudo en ambos extremos del elemento. La representación matricial del modelo es:

Dónde:

\(I_f\): Vector de corrientes del lado primario.

\(I_t\): Vector de corrientes del lado secundario.

\(V_f\): Vector de tensiones del lado primario.

\(V_t\): Vector de tensiones del lado secundario.

\(Y_{ff}\): Matriz 3x3 de admitancia del lado primario.

\(Y_{ft}\): Matriz 3x3 de admitancia del lado primario con el secundario.

\(Y_{tf}\): Matriz 3x3 de admitancia del lado secundario con el primario.

\(Y_{tt}\): Matriz 3x3 de admitancia del lado secundario.

La gran mayoría de algoritmos de cálculo, especialmente aquellos que son competitivos computacionalmente requieren de una matriz de admitancias entre los nudos de la red. Hallando el modelo Pi correspondiente para cada rama, es inmediata la formación de la matriz de admitancia de un circuito. Esto se discute detalladamente en el siguiente capítulo.

Generadores de tensión controlada¶

El generador controlado es una entelequia numérica que a efectos de cálculo sólo necesita que se especifiquen la potencia activa (P) y el módulo de la tensión (\(|V|\)). La ventaja es que en el nodo en el que está conectado el generador, se mantiene el módulo de la tensión se mantienen constante.

El valor de tensión de control se especifica en valores por unidad con respecto a la tensión nominal del nodo. La potencia activa especificada y la impedancia se han de pasar a valores por unidad. Adicionalmente se calcula la potencia reactiva del generador. Si esta potencia reactiva calculada en valores por unidad excede los límites del generador, en el proceso de cálculo se toman medidas como dejar de controlar la tensión en el nodo.

Baterías¶

La betería es un elemento que sustrae o inyecta potencia en cada momento. En la literatura reciente y círculos especializados, se sugiere que las baterías sean simuladas como generadores controlados dónde la potencia activa P puede ser positiva o negativa, dependiendo de si se inyecta o sustrae potencia de la red. En este documento vamos a aceptar esa sugerencia de modelado.

Al modelar la batería como un tipo especial de generador controlado, asumimos lo mismo que ya se ha asumido en éste. Adicionalmente incluimos el parámetro de la capacidad de almacenaje de la batería que nos permitirá determinar el nivel de descarga (\(SoC\)) de ésta en simulaciones tiempo-dependientes.

Cargas: Modelo general ZIP¶

Para modelar una carga de una red eléctrica, se utiliza el denominado modelo ZIP. El modelo está compuesto por una impedancia (Z), una corriente (I) y una potencia (P). Estrictamente las siglas ZIP no representan las magnitudes. La potencia es un valor complejo (S) de potencia activa y reactiva. La corriente es un valor complejo con corriente activa y reactiva y la impedancia es efectivamente una impedancia compleja con valores real e imaginario.

Todas las magnitudes se han de pasar a valores por unidad.

Elementos shunt¶

Los elementos shunt son admitancias de la red. A decir verdad el modelo ZIP ya cubre una impendancia general. No obstante es conveniente incluir los shunt como dispositivos generales porque se puede incluir un cambiador de tomas variable para cambiar la impedancia en el «bucle exterior» del flujo de potencia, al igual que in cambiador de tomas de un transformador.

¿Qué hacemos con los interruptores?¶

Los interruptores son una parte fundamental de las redes eléctricas. Sin embargo su modelado numérico es problemático. Si modelásemos los interruptores como una rama con impedancia zero o infinita entre dos buses, estaríamos metiendo ramas de impedancia muy baja o muy alta en comparación con las demás ramas. En la práctica esto produce admitancias que al ser insertadas en la matriz de admitancia producen lo que se denomina como mal condicionamiento de la matriz. Esto produce que el problema numérico no tenga solución al tender a la divergencia.

Para evitar este problema los interruptores se han de pre-processar como los estados de las ramas a las que afectan. Esto hace que la rama esté activada o desactivada evitando los problemas numericos por completo.

Por ejemplo en la imagen anterior, tenemos una línea con dos interruptores. Uno en cada cabecera. El interruptor unido al bus 2 está abierto, provocando que la línea esté desconectada. Entoncen a la hora de componer las matrices de admitancia (en el siguiente capítulo) simplemente le asignamos el estado 0 a la línea. Si estuviese conectada le asignamos el estado 1.

De forma general podemos decir que el estado de una línea es el producto de los estados binarios de los interruptores que le afectan. En nuestro ejemplo el estado es el producto de 1 x 0 = 0, es decir que el estado de la rama es desconectado.

Voltage source converter (VSC)¶

Se puede pensar en este dispositivo como una «rama» que convierte AC en DC. El siguiente modelo de convertidor de fuente de tensión (o VSC) viene referenciado de [ACHA1].

La función de transferencia es la siguiente:

Dónde:

Alta tensión en corriente continua (HVDC)¶

High Voltage Direct Current o HVDC es un término utilizado para referirse a la transmisión en alta tensión y corriente continua. Este método abarata costes para transmisión a muy larga distancia y también se usa para acoplar systemas eléctricos con diferente base de fecuencia o que por distintas razones, su acople en AC es inestable. [ACHA2] provee un marco de referencia unificado para incorporar los convertidores y las redes en DC en los flujos de potencia tipo Newton-Raphson.

En [ACHA2] se proveen dos ecuaciones de transferencia que vamos a tener que unir. Estas son, la ecuación de transferencia del transformador:

Y la ecuación de transferencia del convertidor VSC:

Dónde:

Como necesitamos una función de transferencia de la parte AC a la parte DC, necesitamos unir ambas funciones de transferencia y eliminar las referencias a \(I_{vi}\) y \(V_{vi}\).

Ahora podemos efectuar la reducción de los dos nudos interiores (2 y 3) con la siguiente operación:

Referencias¶

Compilando la información del gestor de activos¶

En la sección El circuito como gestor de activos se menciona la estructura anidada de objectos que componen la estructura de la red. Esta estructura ha sido refinada con experiencia en diseño de simuladores eléctricos de forma que el paso de la información en objetos a vectores y matrices sea eficiente y sencillo de comprender y mantener.

El siguiente pseudo-código ilustra la función de compilación de objetos a vectores y matrices.

n = circuit.buses.size()
m = circuit.branches.size()
bus_dict = dictionary<int, Bus>

// contar los elementos, esto es bastante rápido
nl = 0  // número de cargas
ng = 0  // número de generadores
nb = 0  // número de baterías
ns = 0  // número de shunts

for i=0:n
    nl += circuit.buses[i].loads.size()
    ng += circuit.buses[i].generators.size()
    nb += circuit.buses[i].batteries.size()
    ns += circuit.buses[i].shunts.size()

// declarar arrays numéricos

// cargas
Pl = zeros(nl)
Ql = zeros(nl)
Irl = zeros(nl)
Iil = zeros(nl)
Gl = zeros(nl)
Bl = zeros(nl)
C_bus_load = zeros(n, nl)

// Generadores
Pg = zeros(ng)
Vg = ones(ng)
C_bus_gen = zeros(n, ng)

// baterías
Pb = zeros(nb)
Vb = ones(nb)
C_bus_batt = zeros(n, nb)

// shunts
Gs = zeros(ns)
Bs = zeros(ns)
C_bus_shunt = zeros(n, ns)

il = 0, ig = 0, ib = 0, is = 0
for i=0:n

    for k=0:circuit.buses[i].loads.size()  // recoger los valores de las cargas
        Pl[il] = circuit.buses[i].loads[k].Pl
        Ql[il] = circuit.buses[i].loads[k].Ql
        Irl[il] = circuit.buses[i].loads[k].Ir
        Iil[il] = circuit.buses[i].loads[k].Ii
        Gl[il] = circuit.buses[i].loads[k].Gl
        Bl[il] = circuit.buses[i].loads[k].Bl
        C_bus_load[i, il] = 1
        il += 1

    for k=0:circuit.buses[i].generators.size()  // recoger los valores de los generadores
        Pg[ig] = circuit.buses[i].generators[k].P
        Vg[ig] = circuit.buses[i].generators[k].V
        C_bus_gen[i, ig] = 1
        ig += 1

    for k=0:circuit.buses[i].batteries.size()  // recoger los valores de las baterías
        Pb[ib] = circuit.buses[i].batteries[k].P
        Vb[ib] = circuit.buses[i].batteries[k].V
        C_bus_batt[i, ib] = 1
        ib += 1

    for k=0:circuit.buses[i].shunts.size()  // recoger los valores de los shunts
        Gs[is] = circuit.buses[i].shunts[k].G
        Bs[is] = circuit.buses[i].shunts[k].B
        C_bus_shunt[i, is] = 1
        is += 1

// recorer las ramas de la red

r = zeros(m)
x = zeros(m)
g = zeros(m)
b = zeros(m)
rate = zeros(m)
C_bus_branch_f = zeros(n, m)
C_bus_branch_t = zeros(n, m)

for i=0: circuit.branches.size()
    // Obtener los índices de los dos buses de la rama
    b1 = bus_dict[circuit.branches[i].bus1]
    b2 = bus_dict[circuit.branches[i].bus2]

    // copiar la información a los arrays
    r[i] = circuit.branches[i].r
    x[i] = circuit.branches[i].x
    g[i] = circuit.branches[i].g
    b[i] = circuit.branches[i].b
    rate[i] = circuit.branches[i].rate
    C_bus_branch_f[b1, i] = 1
    C_bus_branch_t[b2, i] = 1

Matriz de admitancia (Y)¶

Esta sección integra la formación de la matriz de admitancia partiendo de la definición general de rama data en el capítulo Modelo general de rama (Pi). El cálculo de la matriz de admitancia se puede vectorizar completamente de la siguiente manera;

Primero se forman los vectores que representan las admitancias serie (\(Ys\)), la admitancia de derivación (ó shunt) (\(GBc\)) y los valores complejos de desfase (\(tap\)).

Luego se forman los vectores primitivos que servirán para formar la matriz de amitancia. Estos vectores se multiplicarán después por las matrices de conectividad \(C_f\) y \(C_t\) para dar origen a las admitancias \(Y_f\) e \(Y_t\) las cuales tienen utilidad para el cálculo de el flujo de potencia.

Adicionalmente se compone el vector de admitancias debidas a los dispositivos shunt y componente de impedancia de las cargas tipo ZIP. Este vector se añade a la diagonal de la matriz de admitancia.

Ahora se componen las matrices de conectividad modificadas con los estados de las ramas. Esto permite dejar fuera del cálculo aquellas ramas que tienen un estado desconectado.

En el paso final componemos las matrices de admitancia vistas des de el primario (\(Y_f\)) el secundario (\(Y_t\)) además de la matriz de admitancia final a usar en los cálculos (\(Y_{bus}\)).

Dónde:

Matriz de adyacencia (A)¶

La matriz de adyacencia sirve para determinar la conectividad del circuito, y por tanto llegar a calcular las islas que están presentes en él. El cálculo de la matriz de adyacencia se hace a partir de las matrices de conectividad bus-rama que ya tenemos de cálculos anteriores.

Primero calculamos la matriz de conectividad total entre buses y ramas:

Luego calculamos la matriz de conectividad bus-bus, que es la matriz de adyacencia de los nudos de grafo que representa la red:

Detección de islas¶

La matriz de admitancia de un circuito con más de una isla es singular. Por lo tanto, el circuito tiene que ser dividido en subcircuitos para poder ser resuelto. El algoritmo sugerido para encontrar las islas de un circuito es la primera búsqueda de profundidad. (DFS).

Anteriormente ya se había determinado que el gráfico de circuito completo viene dado por la matriz de conectividad Bus-Bus \([C_{bus, bus}]\). Esta matriz también se conoce como la matriz de adyacencia de nodos. Para propósitos algorítmicos lo llamaremos la matriz de adyacencia \(A\). Como nota al margen, la matriz \(A\) es una matriz dispersa.

A efectos algorítmicos, \(A\) se elige para ser una matriz dispersa de CSC. Esto es importante porque el siguiente algoritmo utiliza la estructura dispersa de CSC para encontrar los elementos adyacentes de un nodo.

La siguiente función implementa la versión no recursiva (y por lo tanto más rápida) del DFS que atraviesa la matriz de conectividad bus-bus (también conocida como la matriz de conectividad adyacente).

def find_islands(A):
    """
    Method to get the islands of a graph
    This is the non-recursive version
    :param: A: Circuit adjacency sparse matrix in CSC format
    :return: islands list where each element is a list of the node indices of the island
    """

    # Mark all the vertices as not visited
    visited = np.zeros(self.node_number, dtype=bool)

    # storage structure for the islands (list of lists)
    islands = list()

    # set the island index
    island_idx = 0

    # go though all the vertices...
    for node in range(self.node_number):

        # if the node has not been visited...
        if not visited[node]:

            # add new island, because the recursive process has already
            # visited all the island connected to v

            islands.append(list())

            # -------------------------------------------------------------------------
            # DFS: store all the reachable vertices into the island from current
            #      vertex "node".

            # declare a stack with the initial node to visit (node)
            stack = list()
            stack.append(node)

            while len(stack) > 0:

                # pick the first element of the stack
                v = stack.pop(0)

                # if v has not been visited...
                if not visited[v]:

                    # mark as visited
                    visited[v] = True

                    # add element to the island
                    islands[island_idx].append(v)

                    # Add the neighbours of v to the stack
                    start = A.indptr[v]
                    end = A.indptr[v + 1]
                    for i in range(start, end):
                        k = A.indices[i]  # get the column index in the CSC scheme
                        if not visited[k]:
                            stack.append(k)
                        else:
                            pass
                else:
                    pass
            # -----------------------------------------------------------------------

            # increase the islands index, because all the other connected vertices
            # have been visited
            island_idx += 1

        else:
            pass

    # sort the islands to maintain raccord
    for island in islands:
        island.sort()

    return islands

Topología variable con el tiempo¶

¿Que ocurre si queremos que los estados de las ramas varíen con el tiempo?

Si queremos un motor de topología dónde el tiempo sea una dimensión integrada, debemos procesar todos los estados de conectividad de la red. Esos estados vienen dados por los estados de las ramas (los cuales pueden venir dados por los estados de los interruptores)

La tarea se puede dividir en dos etapas; La primera es detectar cuantos estados de conectividad diferentes existen. Para ellos nos ayudamos del perfil temporal de estados de las ramas, dónde cada fila representa un estado. Después de esto, debemos evaluar el número de islas que aparecen en cada estado, segmentando las matrices de admitancia y los vectores de inyecciones para cada isla y cada estado.

Al final de este proceso, obtenemos un set de islas por cada estado de la red. A la hora de simular los estados temporales, utilizamos la isla del estado correspondiente a cada punto temporal. Así nos aseguramos de estar representando la topología de la red adecuadamente en cada momento.

Inyecciones de potencia, corriente y admitancia¶

En el motor de topología, es necesario computar los consumos y generaciones por nudo de la red. Para ello tenemos que tomar los valores de consumo y generación especificados por dispositivo y agregarlos por nudo. Para ello, debemos haber construido previamente las matrices de conectividad de cada elemento de generación y consumo con los buses a los que están conectados. Entonces, para obtener las magnitudes por bus simplemente se trata de multiplicar la matriz de conectividad correspondiente por el vector de valores del elemento.

Inyecciones de potencia en forma compleja:

Inyecciones de corriente en forma compleja:

Dónde:

Integración de series temporales¶

Podemos extender el cómputo de las inyecciones por bus con perfiles temporales de las magnitudes. Esto permite que el análisis temporal sea un «ciudadano de primera» en nuestro motor de cálculo, porque de otro modo el análisis temporal se limita a ejecutar el motor de topologia muchas veces. Si embargo extendiendo el cálculo al manejo de perfiles obtenemos las variables por bus de forma inmediata.

Inyecciones de potencia en forma compleja:

Inyecciones de corriente en forma compleja:

Procesado topológico avanzado: Reducción de subestaciones y líneas con múltiples secciones¶

La formulación nodal de las ecuaciones de Kirchoff (ecuaciones de inyecciones de corriente) no admite ramas de resistencia cero. Esto es así porque estas ramas hacen la matriz de admitancia singular. Otra forma de verlo, es que esos elementos de resistencia cero se comportan como corto circuitos.

Por tanto, tenemos un problema con los interruptores y trozos de conexión muy cortos que se utilizan en las subestaciones; No podemos incluir la topología de las subestaciones en el modelo de red a simular porque esto nos impediría simular la red con las ecuaciones nodales.

La solución es efectuar una reducción topológica de los interruptores y las ramas de conexión cortas de las subestaciones hasta conseguir la expresión de cálculo; Es decir, a los nudos y ramas que realmente tienen una impedancia significativa.

A continuación vamos a describir mediante un ejemplo el algorítmo desarrollado por un servidor para reducir las subestaciones. Para ello se asume la suiguiente manera de conectar elementos:

• El elemento general de conecividad es la terminal (Terminal en CIM)
• Todas las ramas se conectan a dos terminales.
• Las barras o buses de la subestación son un elemento más y no representan un nodo topológico a priori.

Observemos el siguiente ejemplo:

• Los terminales de conectividad se denotan con T.
• Las barras de la subestación se denotan con B.
• Los interruptores o seccionadores se denotan con SW.
• Las rammas con impedancia significativa (ej. líneas) se denotan con L.

Ahora el lector podría pensar que existe una duplicidad de elementos de conexión, ¿Por qué existen barras y terminales? La respuesta es que las barras son un elemento físico. Comúnmente se llaman barras (o buses) a los nudos de cáclculo de un model de simulación. No obstante, dificilmente serán embarrados reales. Por contrario serán los nudos de cálculo resultantes de la reducción. Aquí es dónde entran en juego las terminales. Las terminales son un elemento ficticio de conexión, por tanto nos permiten unit cualquier cosa con cualquier cosa: dos líneas, una línea con un interruptor, etc.

1. Sustitución

Como existen dos elementos de conexión, sólo debe quedar uno, y no va a ser ni la barra ni la terminal. Será el nudo de cálculo. El primer paso del algorítmo será sustituir las barras y los terminales por unos nudos de cálculo iniciales, que más tarde reduciremos para obtener la red de cálculo. El proceso de sustitución es:

• Cada barra se convierte en un nudo de cálculo (TopologicalNode en CIM).
• Las terminales asociadas a una barra desaparecen, recorando a qué nudo de cálculo quedan vinculados.
• Las terminales que no están asociadas a una barra, se convierten en nudos de cálculo adicionales.

Durante este proceso, tenemos que guardar una relación de los terminales y los nudos de cálculo que los reemplazan. Esto nos permitirá más tarde poder reasignar las ramas de cálculo a los nudos reducidos adecuados.

Entonces, la sustitución de barras y terminales por nudos de cálculo (N) queda de la siguiente manera:

Ahora queda la tarea de quitar los interruptores y determinar qué nudos de cálculo son en realidad el mismo, fruto del estado (abierto / cerrado) los interruptores.

2. Matriz de adyacencia de interruptores

Ahora formamos la matriz de adyacencia (C) de los nudos de cálculo con los interruptores.

• Dimensionamos una matriz M de número de nudos por número de interruptores.

• Para cada interruptor k

  • Obtenemos los índices de los nudos de los extremos (f: from, t: to)
  • M[f, k] = 1 si el interruptor está cerrado, 0 si está abierto.
  • M[t, k] = 1 si el interruptor está cerrado, 0 si está abierto.

• Calculamos \(C = M \times M^t\)

La matriz de conectividad nudos-interruptores (M) es:

     SW1  SW2  SW3  SW4  SW5  SW6  SW7
N1     1    1    0    0    0    0    0
N2     1    0    1    1    0    0    0
N3     0    0    0    0    1    0    0
N4     0    0    0    0    0    1    1
N5     0    0    0    0    0    0    0
N6     0    1    0    0    0    0    0
N7     0    0    1    0    0    0    0
N8     0    0    0    1    0    0    0
N9     0    0    0    0    1    0    0
N10    0    0    0    0    0    1    0
N11    0    0    0    0    0    0    1

La matriz de adyacencia (C) queda como:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    1   3   0   0   0   0   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    1   0   0   0   0   1   0   0   0    0    0
N7    0   1   0   0   0   0   1   0   0    0    0
N8    0   1   0   0   0   0   0   1   0    0    0
N9    0   0   1   0   0   0   0   0   1    0    0
N10   0   0   0   1   0   0   0   0   0    1    0
N11   0   0   0   1   0   0   0   0   0    0    1

La matriz de adyacencia (C) nos indica qué nudos estan conectados por interruptores en primera instancia. No obstante, nosotros quremos saber qué nudos forman un grupo conectado al final.

3. Reducción de nudos

En este paso propagamos la conectividad 1-a-1 de la matriz de adyacencia inicial, hasta conseguir una matriz modificada que si contenga los grupos de nudos.

El algoritmo de este paso es el siguiente:

• recorremos cada columna de índice c.
• Para cada columna c, recorremos las filas de c+1 a N (número de nudos)
• Si nos encontramos con un valor mayor a cero, sumamos a fila que estamos mirando, la fila de indice c.
• Marcamos en un vector que la fila r ha sido reducida.

El codigo python que recoge esto es:

reduced = np.zeros(n_calc_nodes, dtype=int)  # marks the buses that are to be merged
for c in range(n_calc_nodes):
    for r in range(c + 1, n_calc_nodes):
        if C[r, c] > 0:
            C[r, :] += C[c, :]
            reduced[r] += 1

El resultado de los pasos del algoritmo se muestra a continuacion. Como hay 11 nudos en el ejemplo, hay 11 pasos, con 11 matrices de adyacencia modificadas.

C (reduced N1) @ c:0, r:1:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    1   0   0   0   0   1   0   0   0    0    0
N7    0   1   0   0   0   0   1   0   0    0    0
N8    0   1   0   0   0   0   0   1   0    0    0
N9    0   0   1   0   0   0   0   0   1    0    0
N10   0   0   0   1   0   0   0   0   0    1    0
N11   0   0   0   1   0   0   0   0   0    0    1

C (reduced N1) @ c:0, r:5:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    3   1   0   0   0   2   0   0   0    0    0
N7    0   1   0   0   0   0   1   0   0    0    0
N8    0   1   0   0   0   0   0   1   0    0    0
N9    0   0   1   0   0   0   0   0   1    0    0
N10   0   0   0   1   0   0   0   0   0    1    0
N11   0   0   0   1   0   0   0   0   0    0    1

C (reduced N2) @ c:1, r:5:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    0   1   0   0   0   0   1   0   0    0    0
N8    0   1   0   0   0   0   0   1   0    0    0
N9    0   0   1   0   0   0   0   0   1    0    0
N10   0   0   0   1   0   0   0   0   0    1    0
N11   0   0   0   1   0   0   0   0   0    0    1

C (reduced N2) @ c:1, r:6:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    3   5   0   0   0   1   2   1   0    0    0
N8    0   1   0   0   0   0   0   1   0    0    0
N9    0   0   1   0   0   0   0   0   1    0    0
N10   0   0   0   1   0   0   0   0   0    1    0
N11   0   0   0   1   0   0   0   0   0    0    1

C (reduced N2) @ c:1, r:7:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    3   5   0   0   0   1   2   1   0    0    0
N8    3   5   0   0   0   1   1   2   0    0    0
N9    0   0   1   0   0   0   0   0   1    0    0
N10   0   0   0   1   0   0   0   0   0    1    0
N11   0   0   0   1   0   0   0   0   0    0    1

C (reduced N3) @ c:2, r:8:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    3   5   0   0   0   1   2   1   0    0    0
N8    3   5   0   0   0   1   1   2   0    0    0
N9    0   0   2   0   0   0   0   0   2    0    0
N10   0   0   0   1   0   0   0   0   0    1    0
N11   0   0   0   1   0   0   0   0   0    0    1

C (reduced N4) @ c:3, r:9:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    3   5   0   0   0   1   2   1   0    0    0
N8    3   5   0   0   0   1   1   2   0    0    0
N9    0   0   2   0   0   0   0   0   2    0    0
N10   0   0   0   3   0   0   0   0   0    2    1
N11   0   0   0   1   0   0   0   0   0    0    1

C (reduced N4) @ c:3, r:10:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    3   5   0   0   0   1   2   1   0    0    0
N8    3   5   0   0   0   1   1   2   0    0    0
N9    0   0   2   0   0   0   0   0   2    0    0
N10   0   0   0   3   0   0   0   0   0    2    1
N11   0   0   0   3   0   0   0   0   0    1    2

C (reduced N6) @ c:5, r:6:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    9  10   0   0   0   4   3   2   0    0    0
N8    3   5   0   0   0   1   1   2   0    0    0
N9    0   0   2   0   0   0   0   0   2    0    0
N10   0   0   0   3   0   0   0   0   0    2    1
N11   0   0   0   3   0   0   0   0   0    1    2

C (reduced N6) @ c:5, r:7:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    9  10   0   0   0   4   3   2   0    0    0
N8    9  10   0   0   0   4   2   3   0    0    0
N9    0   0   2   0   0   0   0   0   2    0    0
N10   0   0   0   3   0   0   0   0   0    2    1
N11   0   0   0   3   0   0   0   0   0    1    2

C (reduced N7) @ c:6, r:7:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    9  10   0   0   0   4   3   2   0    0    0
N8   18  20   0   0   0   8   5   5   0    0    0
N9    0   0   2   0   0   0   0   0   2    0    0
N10   0   0   0   3   0   0   0   0   0    2    1
N11   0   0   0   3   0   0   0   0   0    1    2

C (reduced N10) @ c:9, r:10:

     N1  N2  N3  N4  N5  N6  N7  N8  N9  N10  N11
N1    2   1   0   0   0   1   0   0   0    0    0
N2    3   4   0   0   0   1   1   1   0    0    0
N3    0   0   1   0   0   0   0   0   1    0    0
N4    0   0   0   2   0   0   0   0   0    1    1
N5    0   0   0   0   0   0   0   0   0    0    0
N6    6   5   0   0   0   3   1   1   0    0    0
N7    9  10   0   0   0   4   3   2   0    0    0
N8   18  20   0   0   0   8   5   5   0    0    0
N9    0   0   2   0   0   0   0   0   2    0    0
N10   0   0   0   3   0   0   0   0   0    2    1
N11   0   0   0   6   0   0   0   0   0    3    3

El vector de marcas de nudos reducidos se muestra a continuación. Las posiciones que tienen un cero, son las de los nudos que se quedan sin reducir.

reduced:
[0 1 0 0 0 2 2 3 1 1 2]

4. Buscar los grupos

En esta etapa, miramos la útima matriz de adyacencia modificada en aquellas columnas que se marcaron como no modificadas, es decir en las que tienen un cero en el vector «reduced»

Entonces, en cada columna elegida, miramos si el elemento (r: row, c: column) para \(r \geq c\) es mayor que cero. Si lo es, entonces significa que el nudo de indice c, reduce al nudo de indice r, por tanto lo incluimos en el grupo.

Alternativamente, si un nudo no reduce a nadie, al menos ha de reducirse a si mismo, por tanto tendremos un grupo de un nudo. Esto lo hacemos para que el diccionario final contenga una representacion completa de toda la red reducida.

groups = dict()
for c in range(n_calc_nodes):
    if reduced[c] == 0:  # the buses that were not marked as reduced are the "master buses"
        group = list()
        for r in range(c, n_calc_nodes):
            if C[r, c] > 0:
                group.append(r)  # the group includes the master bus

        if len(group) == 0:
            group.append(c)  # if the group has no length, add the main bus, because it is not reducible

        groups[j] = group

Los grupos del ejemplo son:

• N1: N1, N2, N6, N7, N8
• N3: N3, N9
• N4: N4, N10, N11
• N5: N5

El modelo de cálculo resultante es el suiguiente:

5. Reasignar los nudos reducidos a las ramas de cálculo

Como habíamos dicho, las ramas están asignadas a unos terminales, y lo que queremos en última instancia es que las ramas estén conectadas a los nudos de cálculo reducidos.

Tras reasignar los nudos de cálculo sobre la tabla del apartado 1, queda así:

La forma de saber qué nudo de cálculo corresponde a cada terminal es:

• Construir un mapeo entre terminales y su nudo de cálculo final.
• Para cada rama, convertir cada uno de sus terminales en el nudo de cálculo reducido correspondiente.

Flujo de potencia en DC (aproximación lineal)¶

Existe una forma de linealizar las ecuaciones de flujo de potencia. Dicha linealización no viene sin coste; para conseguirla se han hecho simplificaciones que se pueden considerar inasumibles en muchos casos. De forma general, la aproximación DC, sólo es válida en sistemas de transmisión y de forma muy limitada a condiciones de funcionamiento del sistema cercanas a las de diseño.

En la aproximación lineal, se considera que los módulos de tensión son los nominales (1 p.u., o lo especificado por el control local) y solamente se calculan los ángulos de las tensiones nodales. El cálculo requiere de la reducción de los nudos Slack, tal y como se ha visto para el método Z-Matrix.

Se calcula la potencia real inyectada en los nudos (reducidos)

Se calculan los ángulos de tensión:

Finalmente se recomponen las tensiones en modo complejo:

Hay que tener en cuenta que esta es una burdísima aproximación de la realidad, pero una aproximación que es útil para poder calcular los flujos de potencia en las ramas de la red de forma rápida. También se necesita componer un vector de tensiones completo al igual que en el método Z-Matrix.

Flujo de potencia lineal AC¶

Existe una formulación simple a la vez que muy potente. Esta es la linealización de las ecuaciones completas de flujo de potencia. Esta linealización hace que el problema de encontrar las tensiones (aproximadas) de la red se reduzca a resolver un sistema de ecuaciones lineales una vez:

Dónde:

• \(G = Re\left(Y_{bus}\right)\)
• \(B = Re\left(Y_{bus}\right)\)
• \(Gs = Im\left(Y_{series}\right)\)
• \(Bs = Im\left(Y_{series}\right)\)
• pq: lista de índices de nudos pq.
• pqpv: lista de índices nudos pq, extendida con la lista de índices de nudos pv.

Una vez resuelto el sistema lineal, las tensiones de la red son:

• \(|V|_{pq} = [1] + \Delta |V|\)
• \(\theta_{pq}=\Delta \theta_{pq}\)
• \(\theta_{pv}=\Delta \theta_{pv}\)

Las tensiones de los nudos slack son conocidas, y los módulos de tensión de los nudos pv también son conocidas. Esta versión de flujo de potencia está especialmente indicada para aplicaciones DMS por ser muy rápida, sacrificando poca exactitud.

Newton-Raphson Canónico¶

El método Newton-Raphson es una aproximación de Taylor de primer orden de la Ecuación del sistema.

La expresión para actualizar la solución de voltaje en el algoritmo de Newton-Raphson es la siguiente siguientes:

Dónde:

• \({V}_t\): Vector de tensiones en la iteración t (tensión actual).
• \({V}_{t+1}\): Vector de tensiones en la iteración t+1 (nueva tensión).
• \({J}\): Matrix Jacobiana.
• \({S}_0\): Vector de potencias especificadas.
• \({S}_{calc}\): Vector de potencias calculadas \({V}_t\).

En forma matricial tenemos:

Esta ecuación se resuelve de forma recursiva hasta obtener una norma infinito del vector \({S}_0 - {S}_{calc}\) menor que la tolerancia.

El algoritmo general es:

• \(j1=0\)

• \(j2=npv+npq\)

• \(j3=j2+npq\)

• \(Vm = |V|\)

• \(Va = angle(V)\)

• \(dVm = zeros(n)\)

• \(dVa = zeros(n)\)

• Calcular \(f\):

  • \(Scalc = V \cdot (Y \times V - I)^*\)
  • \(dS = Scalc - S_0\)
  • \(\Delta P = Re\{dS_{pvpq}\}\)
  • \(\Delta Q = Im\{dS_{pq}\}\)
  • \(f = [\Delta P, \Delta Q]\)

• Calcular el error: \(error=\frac{1}{2} \cdot f \times f^\top\)

• Mientras el error sea mayor que la tolerancia:

  • Calcular el jacobiano: \(J=Jacobiano(Y, V, I, pvpq, pq)\)

  • Resolver el sistema lineal: \(dx = solve(J, f)\)

  • Actualizar el valor de la tensión:

    • \(\mu=1\)
    • \(dVa_{pvpq} = dx_{j1:j2}\)
    • \(dVm_{pq} = dx_{j2:j3}\)
    • \(Vm = Vm - \mu \cdot dVm\)
    • \(Va = Va - \mu \cdot dVa\)
    • \(Vnew = Vm \cdot e^{j \cdot Va}\)

  • Calcular \(f\):

    • \(Scalc = V \cdot (Y \times V - I)^*\)
    • \(dS = Scalc - S_0\)
    • \(\Delta P = Re\{dS_{pvpq}\}\)
    • \(\Delta Q = Im\{dS_{pq}\}\)
    • \(f = [\Delta P, \Delta Q]\)

  • Calcular el error: \(error=\frac{1}{2} \cdot f \times f^\top\)

Jacobiano en ecuaciones de potencia¶

La matriz Jacobiana es la derivada de la ecuación de flujo de potencia para un voltaje dado. conjunto de valores.

Dónde:

• \(J11 = Re\left(\frac{\partial {S}}{\partial \theta}[pvpq, pvpq]\right)\)
• \(J12 = Re\left(\frac{\partial {S}}{\partial |V|}[pvpq, pq]\right)\)
• \(J21 = Im\left(\frac{\partial {S}}{\partial \theta}[pq, pvpq]\right)\)
• \(J22 = Im\left(\frac{\partial {S}}{\partial |V|}[pq pq]\right)\)
• \(\Delta P = Re\{S_0 - S_{calc} \}_{pvpq}\)
• \(\Delta Q = Im\{S_0 - S_{calc} \}_{pq}\)
• \(S_{calc} = {V} \cdot \left({I} + {Y}_{bus} \times {V} \right)^*\)

Ver la sección de Derivadas para ver cómo calcular las derivadas matricialmente.

Cálculo de flujos a través de las ramas¶

Irónicamente, los algoritmos de cálculo de flujo de potencia no calculan la potencia que «fluye» en las ramas de la red. Sólamente calculan las tensiones en los nudos. Entonces, una vez hemos obtenido la solución de las tensiones en todos los nudos, hemos de calcular la corriente y potencia que fluye a través de las ramas. Para eso vamos a usar las matrices de admitancia \(Y_{from}\) e \(Y_{to}\).

Las pérdidas se calculan como la diferencia entre la potencia enviada y recibida por una rama, por tanto, se definen las pérdidas de potencia como:

Introducción¶

El modelo AC/DC unificado (FUBM: Flexible Unified Branch Model) fué desarrollado en [FUBM1] y [FUBM2]

El modelo general considera que todas las ramas de un sistema de potencia se pueden represnetar por el siguiente esquema:

Sistema de ecuaciones¶

Si vemos las derivadas que corponden a cada sub-matriz del Jacobiano, observamos que podemos dar un orden contiguo a las variables para que el sistema se computacionalmente mas eficiente al montar la matriz:

Vector de error¶

Dónde:

Jacobiano¶

Only Pf control elements iPfsh:

Only Qf control elements iQfma:

Only Qf control elements iQfbeq:

Only Vf control elements iVfbeq:

Only Vt control elements iVtma:

Only Qt control elements iQtma:

Only Droop control elements iPfdp:

Derivadas¶

Derivadas necesarias:

Derivadas de potencias nodales:

Derivadas de potencias de rama desde el lado «from»:

Derivadas de potencias de rama desde el lado «to»:

Derivadas de la potencia «droop»:

PTDF¶

En estas situaciones, podemos calcular las matrices de sensibilidad de los parámetros y luego utilizarlas para predecir los estados futuros. Aquí entra en juego el concepto de PTDF (Power Transfer Distribution Factors). PTDF es una matriz que relaciona los cámbios en los flujos de las ramas con los cambios en las inyecciones nodales.

Esta es la forma más general de PTDF, puesto que pueden existir multitud de versiones del mismo concepto como variación de flujo-variación de generación o variación de flujo-variación de cargas

la fórmula para el PTDF nodal es la siguiente:

Dónde:

• \(f_{0, j}\): Flujo por la rama j en el estado sin modificar de la red. Este es un estado cualquiera que se elija.
• \(f_{j}\): Flujo por la rama j en el estado modificado por \(\Delta P_i\).
• \(\Delta P_i\): Variación de potencia en el nudo i.

Esta fórmula es correcta, pero implica calcular «N» flujos de potencia para poder calcular el PTDF. Existe sin embargo una manera analítica de calcular el PTDF que tarda varios ordenes de magnitud menos tiempo.

PTDF Analítico

El PTDF analítico se construye utilizando el concepto de flujo de potencia lineal también conocido como DC.

la formulación matemática es:

La teoría indica que \(\Delta P\) es una matriz casi vacía, dónde por cada columna, en las posiciones fuente va un 1 y en las posiciones sumidero va un -1. Normalmente se toma el nudo slack como sumidero, yendo entonces todos los -1 en la posicion del slack. Pero resulta que si reducimos la Matriz \(B\) para que no sea singular, eliminando la fila y la columna del slack, eliminamos tambien los -1 de \(\Delta P\), quedándonos una matriz de unos en las posiciones de los nudos PQ y PV.

La implementación práctica requiere eliminar la influencia de los nudos slack para que la inversión de \(B\) sea posible. Además, si no deseamos modificar la influencia de los nudos podemos prescindir del uso de \(\Delta P\), obteniendo la siguiente expresión:

Aquí \(B_f\) es la matriz de susceptancias de cada rama para con el nudo from. \(B\) es la matriz de susceptancia. Para poder realizar esta operación debemos eliminar las columnas de los nudos slack en \(B_f\), y las columnas y filas de los nudos slack en \(B\), tal que nos queda:

Alternativamente, si queremos utilizar \(\Delta P\) nos queda:

• \(n\): Número de nudos.
• \(B\): Matriz de susceptancia.
• \(B_f\): Matriz de susceptancia «from».
• \(pqpv\): Lista de índices de los nudos PQ y PV (es decir, lista de indices de los nudos que no son slack) debe estar ordenada.
• \(noref\): Vector construido para saltarse el primer bus.
• \(\Delta P\): Incremento de potencias; Se toma como una matriz diagonal de 1.

• \(\theta\): Vector de ángulos de tensión. Sale de resolver el flujo de potencia DC para todos los

  incrementos unitarios dados por \(\Delta P\).

• \(PTDF\): Matriz PTDF calculada.

El PTDF para los valores de red de ejemplo:

Si queremos distribuir el efecto del slack entre todos los nudos, debemos modificar la matriz \(\Delta P\):

\(\Delta P\) es una matriz de n x n con todos los valores igual a «c», excepto la diagonal que la ponemos todo a 1. \(c\), es un valor constante que equivale al peso unitario de reparto para cada nudo. Podríamos contemplar utilizar valores no uniformes de reparto del peso; En ese caso cada columna del vector \(c\) es:

No obstante, en el caso general tomamos que el reparto uniforme es suficiente.

El resultado del PTDF para la red estándar IEEE 5-bus es la siguiente matriz:

AC PTDF¶

Existe otra variación del PTDF que se construye haciendo uso del Jacobiano que se usa en el flujo de potencia por Newton-Raphson. El resultado final es una matriz de las mismas dimensiones que la matriz PTDF vista anteriormente, dónde los valores se modifican ligeramente.

la formulación matemática es:

Lo que expandido se convierte en:

Dónde:

• \(J_f\): Jacobiano de las potencias activas de rama con respecto a la tensión.
• \(J\): Jacobiano tal como se usa en el flujo de potencia Newton-Raphson.
• \(\Delta P\): Es la misma matriz utilizada en el método PTDF anterior.
• \(\Delta Q\): Todo ceros hasta tener las dimensiones compatibles.
• Derivadas: Ver la sección de derivadas.

El resultado del PTDF para la red propuesta es igual al PTDF ya mostrado.

Una consideración sobre este método de cálculo del PTDF es que depende de un estado particular de la red, puesto que la formulación implica calcular derivadas de la potencia, y estas requieren un valor de tensión. Esto viene en contraposición al PTDF anterior, que no depende del estado de la red, sino de la topología.

PTDF y series temporales¶

Una vez obtenida la matriz PTDF podemos extrapolar los efectos de la variación en los flujos dadas unas inyecciones de potencia nodales. La fórmula es la siguiente:

Lo que en forma matricial queda:

Nótese que la operación resultante para obtener los flujos de potencia activa por las ramas es muy simple y computacionalmente muy eficiente al estar compuesta por operaciones vectoriales.

LODF¶

La matriz LODF (Line Outage Distribution Factors) representa la variación de flujo por las ramas ante un fallo en una de las ramas de la red.

La fórmula de cálculo es:

Dónde:

• \(f_{0, e}\): Flujo por la rama e en el estado sin modificar de la red. Este es un estado cualquiera que se elija.
• \(f_{e}\): Flujo por la rama e en el estado modificado por el fallo de la rama c.
• \(f_{0,c}\): Potencia que fuía por la rama fallada en el estado inicial.

Cada elemento de la matriz LODF representa la proporción del flujo de la rama fallada que va a cada una de las otras ramas de la red. Es signo positivo indica que la rama e absorbe flujo de la rama fallada c. El signo negativo indica que la rama e descarga parte de su flujo en otras ante el fallo de la rama c.

Al igual que el PTDF, existe una manera analítica de calcular el LODF, la cual no requiere realizar el N-1 de la red.

Dónde:

• \(Cf\): Matriz de conectividad de ramas-nudos «from».
• \(Ct\): Matriz de conectividad de ramas-nudos «to».
• \(A\): Matriz de conectividad ramas-nudos.
• \(H\): PTDF de ramas-ramas.
• \(PTDF\): Matriz PTDF calculado previamente.
• \(LODF\): Matriz LODF.

El resultado del LODF para la red de datos de ejemplo:

Obsérvese que la rama fallada se muestra en las columnas, y los flujos de las ramas se ordenan en las filas.

Nota: Parece que generar el LODF con un PTDF con el slack distribuído lleva a la aparición de valores fuera del rango [-1, 1].

LODF y series temporales¶

Hay algo aún más ambicioso que usar el PTDF para calcular series temporales, esto es usar PTDF y LODF para calcular el cubo de flujos temporales ante la contingencia de las ramas de la red. Veamos como hacerlo;

1. Primero calculamos las matrices PTDF y LODF.
2. Calculamos la serie temporal de flujos \(f\) como hemos visto anteriormente.
3. Calculamos el cubo de flujos en contingencia N-1 con la siguiente fórmula:

Esta ecuación queda en forma matricial:

Fallo múltiple¶

Hemos visto que el LODF nos dá los flujos ante contingencias simples. También podemos utilizar el LODF para contingencias múltiples si aplicamos el principio de superposición.

Para el fallo de un par de líneas \(\beta\) y \(\delta\), podemos calcular los flujos afectados como:

Continuamos, calculando el incremento de flujo por una tercera línea no fallada \(\alpha\):

Siendo el flujo post-contingencia múltiple final por la línea \(\alpha\):

Establecido el mecanismo, podemos generalizar esta formulación de la siguiente forma:

Los detalles de implementación son:

Dónde:

• \(fallados\): lista de índices de las lineas falladas simultáneamente.
• \(k\): Número de líneas falladas simultáneamente.
• \(M\): Corresponde al -LODF de las líneas falladas, pero con 1 en la diagonal.
• \(L\): matriz LODF para todas las líneas (filas) y las líneas falladas (columnas).
• \(f\): Vector de flujos base por todas las líneas.
• \(f_c\): Vector de flujos post contingencia múltiple.

OTDF¶

El valor de OTDF (Outage Transfer Distribution Factors) representa la variación de una línea “k” ante el fallo de una línea “l” reaccionando a una inyección en el bus “j”.

Podemos reducir el cubo a una matriz que elija la peor sensibilidad a las inyecciones en los buses. Esto es, reducir la tercera dimensión eligiendo aquellas entradas que son mayores en valor absoluto, pero recordando su signo:

PSDF¶

En el caso de existir transformadores desfasadores de ángulo, es útil calcular el PSDF (Phase Shift Distribution Factors) Esta Matriz indica el cambio en el flujo de las ramas ante el cambio de ángulo de cualquier rama (idealmente desfasadores de ángulo) La formulación completa se indica en [DCPF].

Dónde:

• \(Bd\): Matrix diagonal de reactancias (número de ramas, Número de ramas).
• \(PTDF\): Matriz PTDF calculada previamente.
• \(A\): Matriz de conectividad rama-nudo (número de ramas, Número de nudos)

CSC¶

Existen varios formatos de almacenaje de matrices sparse. De entre ellos el Formato CSC (Compressed Sparse Column) y su análogo CSR (Compressed Sparse Row) son los más extendidos por su eficiencia computacional.

El formato CSC, tiene un vector de datos (data), un vector de punteros de columna (indptr) y un vector (indices) que indica el índice de las filas .

Esto es más sencillo de entender con un ejemplo:

     0  1  2
    _________
0  | 4       |
1  | 3  9    |
2  |    7  8 |
3  | 3     8 |
4  |    8  9 |
5  |    4    |
    ---------
    columnas = 3
    filas = 6

 índices -> 0  1  2  3  4  5  6  7  8  9
 data    = [4, 3, 3, 9, 7, 8, 4, 8, 8, 9]
 indices = [0, 1, 3, 1, 2, 4, 5, 2, 3, 4]
 indptr  = [0, 3, 7, 10]

Obsérvese que en el ejemplo, el vector data contiene los elementos de la matriz insertados en orden columnar. Los otros dos vectores sirven de ayuda para saber las posiciones de fila y columna a la que corresponde cada valor de data.

• data: Almacena los datos en orden columnar.

• indices: Indica el índice de las filas (longitud igual a la longitud de data)

• indptr: La longitud es columnas + 1, guarda los índices iniciales que delimitan una columna.

  el índice final viene dado por el valor siguiente al actual. Por ejemplo; La primera columna (j=0) se relaciona con los datos de 0 a (3-1) de los vectores data e indices:

  indptr[j=0] = 0 -> principio de la columna en data e indices

  indptr[j=0+1] = 3 -> final de la columna en data e indices

  column_idx = 0 -> Índice de la columna (j)

  indices = [0 , 1, 3] -> Índices de fila (i) de la columna (j)

  data = [10, 3, 3] -> Datos asociados

El bucle típico para acceder a los elementos de la matriz es:

for j in range(n):  # para cada columna j ...
   for k in range(indptr[j], indptr[j+1]): # para cada entrada de la columna ....
       i = indices[k]                      # obtener el índice de la fila
       value = data[k]                     # obtener el valor de i, j
       print(i, j, value)

Regla de la cadena¶

Recordemos la regla de la cadena:

Dada la función \(f = x \cdot y\), las derivadas de \(f\) son:

Ahora, necesitamos generalizar esta regla para productos elemento-a-elemento entre vectores. Este tipo de producto entre vectores de llama producto de Hadammard y en la notación de este documento lo hemos denominado igual que el producto escalar. De esta forma podemos definir:

Entonces, las derivadas parciales de \(F\) son:

Conociendo esto podemos afrontar las derivadas de las funciones vectoriales que veremos a continuación.

Tensión¶

Data la tensión:

Dónde \(|V|\) es el múdulo y \(\theta\) es el ángulo, podemos definir el vector unitario \(E\) como:

Dónde:

Entonces utilizando la regla de la cadena, sacamos las derivadas parciales de la tensión:

Potencia¶

Flujo por las ramas¶

Corriente¶

Raíz de documento¶

La estructura raíz hospeda un diccionario con las siguientes entradas:

type: Describe el tipo de archivo JSON, sirve para indicar que este json no es un archivo común

y que su uso es para intercambio de red.

El texto que debe contener es: Grid Exchange Json File

version: Versión del la especificación del archivo.

review: Versión del la revisión de la especificación del archivo.

software: Nombre del programa que creó el archivo.

units: Diccionario de unidades de las magnitudes, debe seguir la misma estructura que devices, pero de manera que hay una entrada de unidades por cada tipo de dispositivo. De esa forma se declaran las unidades de cada parámatro de cada dispositivo.

Por ejemplo:

"units": {
  "Circuit": {
   "time": "Milliseconds since 1/1/1970 (Unix time in ms)"
  },
  "Bus": {
   "vnom": "kV",
   "vmin": "p.u.",
   "vmax": "p.u.",
   "rf": "p.u.",
   "xf": "p.u.",
   "x": "px",
   "y": "px",
   "h": "px",
   "w": "px",
   "lat": "degrees",
   "lon": "degrees",
   "alt": "meters"
  },
  "Generator": {
   "p": "MW",
   "vset": "p.u.",
   "pf": "p.u.",
   "snom": "MVA",
   "enom": "MWh",
   "qmin": "MVAr",
   "qmax": "MVAr",
   "pmin": "MW",
   "pmax": "MW",
   "cost": "\u20ac/MWh"
  },
  "Load": {
   "g": "MVAr at V=1 p.u.",
   "b": "MVAr at V=1 p.u.",
   "ir": "MVAr at V=1 p.u.",
   "ii": "MVAr at V=1 p.u.",
   "p": "MW",
   "q": "MVAr"
  },
  "Shunt": {
   "g": "MVAr at V=1 p.u.",
   "b": "MVAr at V=1 p.u."
  },
  "Line": {
   "rate": "MW",
   "r": "p.u.",
   "x": "p.u.",
   "b": "p.u.",
   "length": "km",
   "base_temperature": "\u00baC",
   "operational_temperature": "\u00baC",
   "alpha": "1/\u00baC"
  },
  "Transformer": {
   "rate": "MW",
   "r": "p.u.",
   "x": "p.u.",
   "b": "p.u.",
   "g": "p.u.",
   "base_temperature": "\u00baC",
   "operational_temperature": "\u00baC",
   "alpha": "1/\u00baC"
  }
}

devices: Diccionario de dispositivos.

profiles: Diccionario de perfiles; misma estructura que devices.

results: Diccionario de resultados.

Con el contenido colapsado, debe tener el siguiente aspecto:

{
    "type": "Grid Exchange Json File",
    "version":   3.0,
    "software": "GridCal",
    "units": {...},
    "devices": {...},
    "profiles": {...},
    "results": {...}
}

Devices¶

"fbase": 50,
"phases": "ps",
"model_version": "1.3.0",
"name": "MyGrid",
"sbase": 100,
"user_name": "User",
"id": "efb91a32cbd84dd495001ead8acd857d",
"comments": "This is a test grid"

"id": "63c0ba21be834fbda5c997b29bc4793a",
"code": "default",
"name": "default"

"id": "2d75268c55784799b69d8bf6a871df5c",
"name": "default",
"code": "0"

"id": "2d75268c55784799b69d8bf6a871df5c",
"name": "default",
"code": "0"

"id": "299d71fd90e145f68e3cdc9ff03895d7",
"name": "Gas"

"id": "299d71fd90e145f68e3cdc9ff03895456",
"name": "Ciclo combinado",
"id_technology_category": "299d71fd90e145f68e3cdc9ff03895d7"

"id": "8aff71fd90e145f68e3cdc9ff03895d7",
"name": "default",
"id_technology_group": "299d71fd90e145f68e3cdc9ff03895456"

"id": "596d19e0639f42e0be5d0887585b9a4e",
"type": 2,
"phases": "ps",
"name": "My bus 1",
"name_code": "1001",
"active": 1,
"is_slack": false,
"vnom": 132.0,
"vmin": 0.899,
"vmax": 1.100,
"rf": 0,
"xf": 0,
"x": 0,
"y": 0,
"h": 0,
"w": 0,
"lat": 0,
"lon": 0,
"alt": 0,
"area": "42fe8cc3a9764556b93d3d27dbbca396",
"zone": "51e1f18908294b4facc762d20f1efbec",
"country": "ef30e70ed16646479fb548bc2a6bc972",
"substation": ""

"id": "096162cf5ade4ce4894baaff1a291fe7",
"type": "line",
"phases": "ps",
"name": "my line 1",
"name_code": "my code 001",
"bus_from": "596d19e0639f42e0be5d0887585b9a4e",
"bus_to": "054768f9518e465a9ecac721aa8c73de",
"active": 1,
"rate": 82.0,
"r": 0.020,
"x": 0.033,
"b": 0.006,
"length": 0.0,
"base_temperature": 20,
"operational_temperature": 20,
"alpha": 0.0033,
"locations": [(-8.054827817,41.94040418),
              (-8.055221703,41.93964657),
              (-8.05670121,41.93781459),
              (-8.05746899,41.936873),
              (-8.060648726,41.93295244)]

"id": "096162cf5ade4ce4894baaff1a291fe7",
"type": "line",
"phases": "ps",
"name": "my dc line 1",
"name_code": "my code 002",
"bus_from": "596d19e0639f42e0be5d0887585b9a4e",
"bus_to": "054768f9518e465a9ecac721aa8c73de",
"active": 1,
"rate": 80.0,
"r": 0.020,
"length": 0.0,
"base_temperature": 20,
"operational_temperature": 20,
"alpha": 0.0033,
"locations": [(-8.054827817,41.94040418),
              (-8.055221703,41.93964657),
              (-8.05670121,41.93781459),
              (-8.05746899,41.936873),
              (-8.060648726,41.93295244)]

{
"id": "068362caafde4ce4894baaff1a291fe7",
"type": "table",
"name": "Tap values 1",
"index": [-4,       -3,     -2,     -1,     0,       1,      2,      3,      4],
"values": [0.96,    0.97,   0.98,   0.99,  1.0,     1.01,    1.02,  1.03,  1.04]
}

"id": "ec04b8678a324672acb5b7c95bf25aad",
"type": "transformer",
"phases": "ps",
"name": "my transformer",
"name_code": "my name code 003",
"bus_from": "16b003d418df4b97b9453f8b3291aec1",
"bus_to": "53a300acd0714636a54a97a8aa71a41a",
"active": 0,
"rate": 60.0,
"r": 0.0,
"x": 0.35,
"g": 0.0,
"b": 0.0,

"tap_module": 0.98,
"min_tap_module": 0.96,
"max_tap_module": 1.04,
"id_tap_module_table": ""

"tap_angle": 0.0,
"min_tap_angle": -6.28,
"max_tap_angle": 6.28,
"id_tap_angle_table": "068362caafde4ce4894baaff1a291fe7"

"control_mode": 0,
"vset": 1.0,
"pset": 0.0,

"base_temperature": 20,
"operational_temperature": 20,
"alpha": 0.0033

"id": "c86d942555cb46bd9a8710442bddbfed",
"type": "generator",
"phases": "ps",
"name": "Generador ",
"name_code": "Gen2345"
"bus": "596d19e0639f42e0be5d0887585b9a4e",
"active": 1,
"is_controlled": true,
"p": 24.0,
"pf": 0.94,
"vset": 1.02,
"snom": 43.0,
"qmin": -12.0,
"qmax": 12.0,
"pmin": 0.0,
"pmax": 41.0,
"cost": 0,
"technology": "38d4fa12ebff4e4a910f08397fa5ae06"

"id": "c86d942555cb46bd9a8710442bddbfed",
"type": "battery",
"phases": "ps",
"name": "Battery",
"name_code": "Bat345"
"bus": "596d19e0639f42e0be5d0887585b9a4e",
"active": 1,
"is_controlled": true,
"p": 24.0,
"pf": 0.95,
"vset": 1.01,
"snom": 43.0,
"qmin": -12.0,
"qmax": 12.0,
"pmin": 0.0,
"pmax": 41.0,
"cost": 0,
"technology": "38d4fa12ebff4e4a910f08397fa5ae06"

"id": "63f751f752d9429bb8780b9cbf3270cc",
"type": "static_generator",
"phases": "ps",
"name": "StaGen 2 ",
"name_code": "2000",
"bus": "16b003d418df4b97b9453f8b3291aec1",
"active": 1,
"p": 6.5,
"q": 2.2

"id": "63f751f752d9429bb8780b9cbf3270cc",
"type": "load",
"phases": "ps",
"name": "Load 1",
"name_code": "my name code 004",
"bus": "16b003d418df4b97b9453f8b3291aec1",
"active": 1,
"g": 0.0,
"b": 0.0,
"ir": 0.0,
"ii": 0.0,
"p": 6.2,
"q": 2.3

"id": "deb2195e03cf4070859b2059a3d17b1a",
"type": "shunt",
"phases": "ps",
"name": "Shunt",
"bus": "68adb547e8ca4218925cf7c400422eab",
"active": 1,
"controlled": 1,
"g": 0.0,
"b": 0.0
"bmax": 5.0,
"bmin": 0.0,
"id_impedance_table": "deb2195e03cf4070859b2059a3d17b1b"

Profiles¶

Tiene la misma estructura que «Devices» pero los objetos contienen sólo aquellas propiedades con perfiles. Además, los valores de cada propiedad es una lista de valores.

Results (Opcional)¶

Esta sección incluye resultados que se quieran enviar junto con el archivo JSON.

"power_flow": {
                "bus": {
                            "596d19e0639f42e0be5d0887585b9a4e": {
                                                                 "va": 0.16,
                                                                 "vm": 1.02
                                                                }, ...
                       },
                "branch": {
                            "096162cf5ade4ce4894baaff1a291fe7": {
                                                                 "q": 8.6,
                                                                 "p": 24.4,
                                                                 "losses": 0.0
                                                                 }, ...
                          }
                }

Raíz de documento¶

La estructura raíz hospeda un diccionario con las siguientes entradas:

• type: Describe el tipo de archivo JSON, sirve para indicar que este json no es un archivo común y que su uso es para intercambio de red. El texto que debe contener es: Grid Exchange Json File
• version: Versión del la especificación del archivo.
• review: Versión del la revisión de la especificación del archivo.
• software: Nombre del programa que creó el archivo.
• devices: Diccionario de dispositivos. Sólo los datos de diseño.
• data: Datos operacionales con perfil de tiempo; misma estructura que devices. Opcional.
• topology: Datos sobre el procesado topológico. Contiene las correspondencias de los nudos de conectividad a los nudos de cálculo. Opcional.
• results: Diccionario de resultados. Opcional.

Con el contenido colapsado, debe tener el siguiente aspecto:

{
    "type": "Grid Exchange Json File",
    "version": 4.0,
    "software": "GridCal",
    "units": {...},
    "devices": {...},
    "data": {...},
    "topology": {...},
    "results": {...}
}

Devices¶

"id": "efb91a32cbd84dd495001ead8acd857d",
"phases": "ps",
"fbase": 50,
"model_version": "1.3.0",
"name": "MyGrid",
"sbase": 100,
"user_name": "User",
"comments": "This is a test grid"

"id": "63c0ba21be834fbda5c997b29bc4793a",
"code": "default",
"name": "default"

"id": "2d75268c55784799b69d8bf6a871df5c",
"name": "default",
"code": "0"

"id": "2d75268c55784799b69d8bf6a871df5c",
"name": "default",
"code": "0"

"id": "299d71fd90e145f68e3cdc9ff03895d7",
"name": "Gas"

"id": "299d71fd90e145f68e3cdc9ff03895456",
"name": "Ciclo combinado",
"id_technology_category": "299d71fd90e145f68e3cdc9ff03895d7"