Documente Academic
Documente Profesional
Documente Cultură
PROFESOR GUÍA:
LUIS SANTIAGO VARGAS DÍAZ
MIEMBROS DE LA COMISIÓN:
OSCAR EDUARDO MOYA ARAVENA
JUAN PABLO TOLEDO TORRES
SANTIAGO DE CHILE
2008
RESUMEN
eléctricos, que quieren llevar a cabo estos estudios bajo su propio punto de
los que varios de estos programas se pueden comunicar entre sí, pudiendo
programas que son muy útiles, pero que no tienen correspondencia, o no son
este estudio, aparece una combinación de estos casos, en los que por una
tercer software, más completo que los anteriores que no posee esta
capaz de unir a estos 3 programas, y que sea capaz de crear una Base de
2
Se utilizaran los programas Power Factory – Digsilent, Power World y
3
AGRADECIMIENTOS
Son muchos a quienes a lo largo del tiempo han dejado una huella en
mí. Experiencias de las que puedo recordar nombre y descubrir que a lo largo
del camino todo es motivo de alegría y gratitud. De creer en la vida y en todos
los que me ayudaron a terminar esta etapa de mi vida.
A mis familiares, abuelita, tíos, tías, primos que a lo largo de los años me
han hecho sentir parte de una familia grande y cariñosa, sin obligación.
A mis amigos que con el correr de los años han seguido estando ahí a mi
lado, con los que me reencontrado, a los que he visto crecer y formar familias, y
me han demostrado que no es necesario olvidar para seguir adelante.
4
Contenido
RESUMEN ......................................................................................................................2
AGRADACIMIENTOS .....................................................................................................4
TABLA DE ILUSTRACIONES ........................................................................................7
CAPÍTULO 1. ..................................................................................................................8
INTRODUCCIÓN.............................................................................................................8
1.1 Generalidades ................................................................................................... 8
1.2 Objetivos ........................................................................................................... 9
1.2.1 Objetivos Generales.......................................................................................... 9
1.2.2 Objetivos Específicos ........................................................................................ 9
1.3 Estructura del Trabajo ....................................................................................... 9
CAPÍTULO 2. ................................................................................................................11
ASPECTOS GENERALES ...........................................................................................11
2.1 Resumen ......................................................................................................... 11
2.2 Introducción .................................................................................................... 11
2.3 Herramientas Usadas Para el Análisis de Sistemas de Potencia ................... 12
2.4 Métodos Para Realizar el Cálculo de Flujo de Potencia ............................ 16
2.4.1 Método de Gauss – Seidel. ............................................................................. 20
2.4.2 Método de Newton – Raphson. ....................................................................... 21
2.4.3 Método Desacoplado Rápido. ......................................................................... 22
2.5 Ejemplos de Programas en el Mercado. ......................................................... 24
2.5.1 Power - World Simulator (3): ........................................................................... 24
2.5.2 SimPowerSystem (4): ....................................................................................... 25
2.5.3 PSS/E (5): ........................................................................................................... 25
2.5.4 RTDS Simulator (6): .......................................................................................... 26
2.5.5 ETAP (7): ............................................................................................................ 27
2.5.6 Power Factory (Digsilent) (8): .......................................................................... 27
2.5.7 EDSA: .................................................................................................................. 28
2.5.8 ABB Advise GridView (10): .............................................................................. 29
CAPÍTULO 3. ................................................................................................................30
DATOS PARA DISTINTOS TIPOS DE ANÁLISIS DE SISTEMAS ELÉCTRICOS. ....30
5
3.1 Resumen ......................................................................................................... 30
3.2 Introducción .................................................................................................... 30
3.3 Datos para el Flujo de Potencia ...................................................................... 31
3.4 Datos de Secuencia ........................................................................................ 33
3.5 Datos para Análisis Dinámicos ....................................................................... 34
3.6 Uso de Power Factory – Digsilent y Power System Simulator for
Engineering (PSS/E) .................................................................................................. 35
3.7 Archivos Creados para la Base de Datos ....................................................... 35
CAPÍTULO 4. ................................................................................................................47
BASE DE DATOS PARA CREAR ARCHIVOS GENERALES DE SISTEMAS
ELÉCTRICOS. ..............................................................................................................47
4.1 Resumen ......................................................................................................... 47
4.2 Introducción .................................................................................................... 47
4.3 Planteamiento del Problema ........................................................................... 47
4.4 Datos de Entrada de Base de Datos............................................................... 48
4.5 Creación del Diseño ........................................................................................ 50
CAPÍTULO 5. ................................................................................................................52
CASOS PRÁCTICOS DE ANÁLISIS ............................................................................52
5.1 Resumen ......................................................................................................... 52
5.2 Introducción .................................................................................................... 52
5.3 Casos de Estudio ............................................................................................ 53
CAPÍTULO 6. ................................................................................................................62
CONCLUSIONES .........................................................................................................62
Bibliografía ...................................................................................................................64
ANEXOS .......................................................................................................................66
1. Código Script ......................................................................................................... 66
2. Datos de Reguladores de Voltaje .......................................................................... 86
3. Datos de Reguladores de Turbina ......................................................................... 89
4. Datos de Estabilizadores de Potencia. .................................................................. 92
6
TABLA DE ILUSTRACIONES
7
CAPÍTULO 1.
INTRODUCCIÓN
1.1 Generalidades
mostrará una metodología para crear una base de datos, con toda la
8
1.2 Objetivos
y éste deberá generar archivos compatibles con los softwares Digsilent, PSS/E
9
En el capítulo dos, se exponen brevemente los distintos métodos de
son recopilados, ya sea para el estudio de flujos de potencia, como para hacer
información y la forma en como es seleccionada para ser utilizada por cada uno
10
CAPÍTULO 2.
ASPECTOS GENERALES
2.1 Resumen
2.2 Introducción
sistema utilizando componentes RLC (1). En los años 70 estos métodos fueron
grandes gastos de tiempo en el cálculo mientras más complejas eran las redes
eléctricas (2).
operativo (2).
fáciles de interpretar, ya que éstos serán son los que se utilizarán para la toma
de decisiones (3).
12
Figura 1, Evolución de las herramientas computacionales utilizadas en estudios de sistemas eléctricos (3)
13
Raphson es más adecuado para sistemas de distribución, mientras que el de
transformadores.
análisis de armónicos.
dependientes de la frecuencia.
14
Cuando se quiso añadir a los cálculos las restricciones económicas
análisis anteriormente descritas, tienen que contar con una interfaz gráfica
(graphical user interface o GUI) para interactuar con el usuario. Alguna de las
reportes de los eventos, que utilice distintos colores para cada tipo de
15
2.4 Métodos Para Realizar el Cálculo de Flujo de Potencia
estacionario en todas las barras de toda una red, y a partir de ese cálculo, los
eléctrico, que se encuentra dentro de una red eléctrica, y que está conectada a
Figura 2, Modelo General de una Barra (1).
16
· · 0 .1
la red del sistema bajo estudio. La forma que toma la matriz de admitancia
como:
· · .4
expresa como:
· .5
17
Con la ecuación 4 y 5, se obtienen las relaciones de potencia activa y
| | · cos
| | · sen
Es por esto que para cada barra del sistema, su estado para efectos del
valor del módulo del voltaje y su ángulo, los valores de la potencia activa y
reactiva (1).
De estas variables, se elijen dos de ellas para calcular las otras dos, y así
siguiente manera:
• Barra PV
• Barra PQ
19
Con esta clasificación, y dado que la relación entre las potencias y el
voltaje en una barra no es lineal (ec. 5, 6 y 7), para resolver el problema de flujo
función de los voltajes en todas las barras obtenidos en una iteración anterior
del modelo.
∑ ·
.8
voltaje entre dos iteraciones sucesivas para todas las barras, excepto para la
20
se puede emplear un factor ( [1,3; 1,7]) para acelerar la convergencia al
de aceleración)
.9
necesita una cantidad mayor de iteraciones que las utilizadas por otros métodos
relacionan las potencias con el módulo y ángulo del voltaje, que puede ser
escrita como:
Δ | | ∆
· . 10
Δ ∆| |
| |
de voltaje como:
21
∆
. 11
∆| |
0.001 ∆ 0.001.
matriz jacobiana del sistema. Si un sistema tiene n barras, de las cuales g son
tamaño del sistema. Además el error del módulo de potencia converge en forma
lineal. El contra que tiene este método es que generalmente se hacen más
del sistema. El método Desacoplado Rápido (2), es una variante que introduce
22
operación normales del sistema. Este método genera una matriz jacobiana,
resistencia de la línea.
p.u.
cos 0 0 0 . 12
| |
23
∆ · ∆
. 13
∆ · ∆| |
. 14
2·
. 15
método.
24
extremadamente amigable y de gran interactividad, incluye diagramas
Utiliza los más avanzados métodos probados para realizar estudios de flujo de
25
especificadas por el usuario, cumpliendo al mismo tiempo las limitaciones de
criterios de análisis. Además consta de una moderna interfaz gráfico con menús
sistemas con HVAC (high voltaje alternating current) y HVDC (high voltaje direct
current). El simulador RTDS tiene una interfaz gráfica, RSCAD, el cual puede
26
resultados. Básicamente el simulador RTDS tiene dos elementos principales, la
costo por uso de energía, y coordinación de dispositivos. ETAP tiene una familia
PanelSystem.
27
de datos orientada al objeto (Object-Oriented). El usuario puede desarrollar
máximo de 100, 250 e infinitas barras, dependiendo del tipo de licencia que se
2.5.7 EDSA:
28
que existen en una red eléctrica. El programa contiene distintos módulos que
transmisión.
29
CAPÍTULO 3.
ELÉCTRICOS.
3.1 Resumen
3.2 Introducción
de potencia (SEP).
sistema.
que pueden ocurrir en el sistema, como por ejemplo las fallas monofásicas,
30
3.3 Datos para el Flujo de Potencia
utilizados.
o Potencia en [MVA].
o Corriente en [kA].
o Factor de Potencia.
31
o Limite superior e inferior de la Potencia Real y Reactiva.
[p.u].
2) en [p.u]
32
• Etc.
Los datos mínimos necesarios para crear esta base de datos son:
cada una.
de conexión que cada uno tiene, por ejemplo el lado de alta esta
33
en conexión delta y el lado de baja en configuración estrella con
[p.u].
• Etc.
Estos datos son necesarios para poder modelar cada una de las
• Modelo de Cargas.
• Modelo de protecciones.
• Etc.
34
3.6 Uso de Power Factory – Digsilent y Power System Simulator
desde la página oficial del CDEC – SING. Estos datos están ingresados en los
exportado .dz, los cuales fueron extraídos a Microsoft Excel para luego generar
archivos “.raw” (sin formato) utilizables por los softwares PSS/E y Power World.
(lectura / escritura).
Para realizar el traspaso desde los archivos Digsilent (.dz) a Excel (.xls),
Este proceso llevo los datos a formato .txt. Luego se abren estos archivos con
Estos archivos “raw” pueden ser leídos por Digsilent, PSS/E y Power
Digsilent.
35
El Script genera tres archivos, el primero utilizado para el cálculo del flujo
Set: Con este comando se definen las variables que contendrán un listado de
object : Se definen las variables que contiene cada uno de los elementos
string: Se usa para definir las variables alfabéticas que se encuentran en los
int: Se utiliza para definir variables de tipo entero, se utilizan generalmente para
fopen: Se utiliza para crear un archivo de texto. En este caso se generan tres
archivos estos son raw.txt, seq.txt y dyr.txt. El primero contiene los datos
dinámico.
36
Luego de definir los tipos de variables a utilizar, se comienza a extraer datos
desde Digsilent:
37
o React.Pow. Mvar: Potencia reactiva de la carga en [MVar]
[MVA].
38
while (exista una red){
[MVA].
39
o R1-2 [pu]: Parámetro R (resistencia), de secuencia positiva en
[pu].
servicio.
40
Con esto se termina la recopilación de datos para el cálculo de flujo de
secuencia.
este formato:
este formato:
41
while (exista una red) {
este formato:
este formato:
carga.
carga.
42
• Se eligen los datos de impedancia de secuencia cero de las cargas de
este formato:
• Se eligen los datos de secuencia cero de las líneas de todas las redes
43
o Name: Nombre del generador.
(D, Y o YN).
• Se eligen los datos del modelo general de cada generador de todas las
44
o Rotor Type: Tipo de rotor (polos salientes, tipo jaula de ardilla)
anexos.
45
para distintos tipos de generadores, estos datos se detallan en los
anexos.
en los anexos.
46
CAPÍTULO 4.
SISTEMAS ELÉCTRICOS.
4.1 Resumen
4.2 Introducción
datos, la forma en que son manejados, y el producto final, que se refiere a los
archivos generados para ser utilizados por los softwares disponibles (Digsilent,
forma particular por cada uno de los softwares del mercado, es decir, cada
47
como ingresar datos, siendo la de algunos más gráfica y didáctica, y en otros
Es por esto que surge la necesidad de crear una base de datos que trate
a cada elemento del sistema de forma general y sencilla. Para esto se elige una
desde Digsilent (donde se tienen los datos actualizados del sistema), y crear
archivos de texto, en formato legible directamente por Excel, los cuales serán
utilizados.
Los datos requeridos por los programas Power World, PSS/E y Digsilent,
son distintos (en cantidad) ya que cada uno de estos programas maneja la
capacitado para realizar estudios de flujos de potencia, aún así este programa
tiene una interfaz bastante sencilla y didáctica, lo que lo hace un programa muy
capaz de hacer estudios dinámicos de fallas. Es por esto que requiere una
48
mayor cantidad de datos de los que necesita Power World, precisando un
se desarrollan, y los resultados del PSS/E serán comparados con los resultados
fácil de ocupar. Aún así trabajar con Digsilent es complicado, ya que, por
ocupar”. Digsilent realiza, entre otras cosas, flujos de potencia, análisis de fallas
sistemas de control).
49
estos se encuentran en lenguaje críptico (formato .dz), y es por esto que es
necesario crear una forma (script) para llevar la información desde Digsilent a
dinámico, los datos tendrían que hacerse uno por uno, por cada generador. Es
por esto que se hace uso del script, para hacer el traspaso de información en
50
Figura 3, Tabla de Script Visto en Notepad
figura:
Figura 4, Tabla de Script Visto en Excel
Este formato se repite para cada tipo de dato, y para cada archivo, esto
Cuando Excel genera los archivos raw, estos están en formato raw tipo
51
CAPÍTULO 5.
5.1 Resumen
5.2 Introducción
52
5.3 Casos de Estudio
Para realizar los distintos casos de estudio, hay que tener en cuenta que
aproximada de 600 MW que tendrá posible conexión con las barras del
Escondida y Encuentro.
Salta.
53
Con estos datos se crea el siguiente cuadro:
Encuentro.
54
realiza el caso base, existen barras que se encuentran por debajo de 0.95 en
estudio). Luego se muestran en rojo aquellas barras que tienen directa relación
con los cambios hechos y que modificaron y luego se marca en color verde
p.u. p.u.
rw AG Salta- Pozo Almonte Cerro Colorado Línea crucero
Terminal(1) Andes 0.9496783 12 Encuentro 0.8695532
Linea crucero
Andes 345 SING 0.9496636 Laberinto Oeste 13.2 Encuentro 0.886408
Linea crucero
Andes Reactor Shunt 345 SING 0.9496636 Lagunas Norte 23 Encuentro 0.9005405
Linea crucero
Calama Santa Margarita 23 SING 0.9486859 Parinacota 13.8 Encuentro 0.9183257
Linea crucero
Tocopilla 5 E SING 0.9443493 SS/AA CTM1 4.16 Encuentro 0.9389611
Pozo Almonte Cerro Colorado Linea crucero
12 SING 0.9422563 Andes 345 Encuentro 0.943405
Linea crucero
SS/AA CTM1 4.16 SING 0.9374819 Andes Reactor Shunt 345 Encuentro 0.943405
55
El mismo análisis fue hecho para cada uno de los casos, es decir, se
adquiriendo los datos con la ayuda del script hecho para extraer datos del
Digsilent. Los datos fueron llevados a un archivo .txt, que maneja mediante
observa que los datos extraídos por el script difieren en el 6° decimal, lo que no
p.u p.u.
rw AG Salta- Pozo Almonte Cerro Colorado Linea crucero
Terminal(1) Andes 0.949678 12 Encuentro 0.869553
Linea crucero
Andes 345 SING 0.949664 Laberinto Oeste 13.2 Encuentro 0.886408
Linea crucero
Andes Reactor Shunt 345 SING 0.949664 Lagunas Norte 23 Encuentro 0.90054
Linea crucero
Calama Santa Margarita 23 SING 0.948686 Parinacota 13.8 Encuentro 0.918326
Linea crucero
Tocopilla 5 E SING 0.944349 SS/AA CTM1 4.16 Encuentro 0.938961
Pozo Almonte Cerro Colorado Linea crucero
12 SING 0.942256 Andes 345 Encuentro 0.943405
Linea crucero
SS/AA CTM1 4.16 SING 0.937482 Andes Reactor Shunt 345 Encuentro 0.943405
56
Se repite este proceso para los 12 casos, para barras, generadores y
líneas.
Ahora se procede a crear el archivo .raw que será leído por los
programas PowerWorld y PSS/E. Este archivo es creado para la versión raw 26,
e incluye todos los datos necesarios para hacer estudios de flujos de potencia.
0 Barras 0 100
Nom.L-L Ul. Magnitude Magnitude Angle
Name Station Grid Volt.kV kV p.u deg SING
m:phi nu
loc_name fold_id e:uknom m:Ul m:u u m 2007
-
Alto Norte 11.08 1 '1 ' 13.8 1 0 0 1 1
B1 13.8 #1 SING 13.8 13.8464 1.00336 26 1 1 1 1.00336 -11.0826 1
-
Alto Norte 11.08 2 '2 ' 13.8 1 0 0 1 1
B2 13.8 #1 SING 13.8 13.8464 1.00336 26 1 2 1 1.00336 -11.0826 1
-
Alto Norte 10.47 3 '3 ' 13.8 1 0 0 1 1
B1 13.8 #2 SING 13.8 13.7587 0.997005 34 1 3 1 0.997005 -10.4734 1
-
Alto Norte 10.47 4 '4 ' 13.8 1 0 0 1 1
B2 13.8 #2 SING 13.8 13.7587 0.997005 34 1 4 1 0.997005 -10.4734 1
-
Antofagasta Antofagast 9.539 5 '5 ' 13.8 1 0 0 1 1
13.8 A a 13.8 SING 13.8 13.7251 0.994572 45 1 5 1 0.994572 -9.53945 1
-
Antofagasta Antofagast 9.539 6 '6 ' 13.8 1 0 0 1 1
13.8 B a 13.8 SING 13.8 13.7251 0.994572 45 1 6 1 0.994572 -9.53945 1
-
25.04 7 '7 ' 23 1 0 0 1 1
B1 Calama 23 SING 23 22.4503 0.976101 54 1 7 1 0.976101 -25.0454 1
-
25.04 8 '8 ' 23 1 0 0 1 1
B2 Calama 23 SING 23 22.4503 0.976101 54 1 8 1 0.976101 -25.0454 1
Chacaya 27.10 9 '9 ' 220 1 0 0 1 1
Chacaya 1 220 SING 220 220.66 1.003 68 1 9 1 1.003 27.1068 1
Figura 8, Creación de formato raw 26
satisfactoriamente.
57
Figura 9, Vista de PowerWorld
Hay que agregar que además de los datos que se ingresan desde la base de
se hace porque pueden existir elementos en servicio, pero que el switch que los
58
Figura 10, Datos Ingresados al Power World
hacer un cálculo de flujo de potencia, y el que entrega Power World para uno de
59
Linea Crucero Encuentro Linea Crucero Encuentro
Nombre En la carpeta u, Magnitud Nombre En la carpeta u, Magnitu %
p.u. p.u.
Pozo Almonte Cerro Colorado Linea crucero Encu 0.869553 Pozo Almonte Cerro Colorado 1Linea crucero En 0.869553 0
Laberinto Oeste 13.2 Linea crucero Encu 0.886408 Laberinto Oeste 13.2 Linea crucero En 0.886408 0
Lagunas Norte 23 Linea crucero Encu 0.900541 Lagunas Norte 23 Linea crucero En 0.891535 0.01
Parinacota 13.8 Linea crucero Encu 0.918326 Parinacota 13.8 Linea crucero En 0.899959 0.02
SS/AA CTM1 4.16 Linea crucero Encu 0.938961 SS/AA CTM1 4.16 Linea crucero En 0.95774 -0.02
Andes 345 Linea crucero Encu 0.943405 Andes 345 Linea crucero En 0.933971 0.01
Andes Reactor Shunt 345 Linea crucero Encu 0.943405 Andes Reactor Shunt 345 Linea crucero En 0.952839 -0.01
Terminal(1) rw AG Salta-Andes 0.943418 Terminal(1) rw AG Salta-And 0.952852 -0.01
Tocopilla 5 E Linea crucero Encu 0.944683 Tocopilla 5 E Linea crucero En 0.944683 0
Calama Santa Margarita 23 Linea crucero Encu 0.954984 Calama Santa Margarita 23 Linea crucero En 0.983633 -0.03
Pozo Almonte 13.8 AT2 Linea crucero Encu 0.896607 Pozo Almonte 13.8 AT2 Linea crucero En 0.923505 -0.03
Pozo Almonte 13.8 AT5 Linea crucero Encu 0.912641 Pozo Almonte 13.8 AT5 Linea crucero En 0.885262 0.03
Radomiro Tomic 23 Linea crucero Encu 0.921741 Radomiro Tomic 23 Linea crucero En 0.921741 0
Pozo Almonte 24 Linea crucero Encu 0.922722 Pozo Almonte 24 Linea crucero En 0.904268 0.02
Pozo Almonte Pampino 24 Linea crucero Encu 0.922798 Pozo Almonte Pampino 24 Linea crucero En 0.895114 0.03
Arica 13.2 Linea crucero Encu 0.878078 Arica 13.2 Linea crucero En 0.886859 -0.01
Pozo Almonte Cerro Colorado Linea crucero Encu 0.906673 Pozo Almonte Cerro Colorado 1Linea crucero En 0.897607 0.01
Arica Chapiquiña 3 Linea crucero Encu 0.911808 Arica Chapiquiña 3 Linea crucero En 0.920926 -0.01
CD Iquique MSIQ 6.6 Linea crucero Encu 0.912819 CD Iquique MSIQ 6.6 Linea crucero En 0.903691 0.01
CD Arica 13.8 Linea crucero Encu 0.916886 CD Arica 13.8 Linea crucero En 0.898548 0.02
La Cascada 66 Linea crucero Encu 0.919984 La Cascada 66 Linea crucero En 0.910784 0.01
CD Arica 66 Linea crucero Encu 0.928724 CD Arica 66 Linea crucero En 0.91015 0.02
ED Tap-off Quiani ED CD Arica-Arica 0.928769 ED Tap-off Quiani ED CD Arica-Aric 0.938057 -0.01
Arica 66 Linea crucero Encu 0.928799 Arica 66 Linea crucero En 0.919511 0.01
Terminal(1) rw ED Chapiquiña- 0.929439 Terminal(1) rw ED Chapiquiñ 0.938733 -0.01
Arica Cerro Chuño 13.8 Linea crucero Encu 0.929503 Arica Cerro Chuño 13.8 Linea crucero En 0.948093 -0.02
Iquique Cavancha 4.16 Linea crucero Encu 0.930458 Iquique Cavancha 4.16 Linea crucero En 0.958371 -0.03
B1 Escondida Laguna 0.930679 B1 Escondida Lagun 0.912065 0.02
B2 Escondida Laguna 0.930679 B2 Escondida Lagun 0.902759 0.03
B2.0 Escondida Laguna 0.930679 B2.0 Escondida Lagun 0.949292 -0.02
Arica El Aguila Quiborax Linea crucero Encu 0.938645 Arica El Aguila Quiborax Linea crucero En 0.910486 0.03
Laberinto Minsal 110 Linea crucero Encu 0.939412 Laberinto Minsal 110 Linea crucero En 0.911229 0.03
Laberinto Minsal 23 Linea crucero Encu 0.939588 Laberinto Minsal 23 Linea crucero En 0.920796 0.02
Terminal rw ED Chapiquiña- 0.942091 Terminal rw ED Chapiquiñ 0.942091 0
B1 Escondida B2 69 0.947401 B1 Escondida B2 69 0.947401 0
B2 Escondida B2 69 0.947401 B2 Escondida B2 69 0.947401 0
Escondida El Peñon 6.6 Linea crucero Encu 0.947717 Escondida El Peñon 6.6 Linea crucero En 0.966671 -0.02
Pozo Almonte Tamarugal 66 Linea crucero Encu 0.948033 Pozo Almonte Tamarugal 66 Linea crucero En 0.919592 0.03
Figura 11, Comparación de Barras entre Power world y Digsilent
60
Linea Encuentro Crucero Linea Encuentro Crucero
Nombre Nivel de Carga Nombre Nivel de Carga
% %
xrw GA Zaldívar-Escond 128.0879 xrw GA Zaldívar-Escondida B 125.526142 ‐0.020408163
zrw ED Pozo Almonte-Pa 121.1255 zrw ED Pozo Almonte-Pampino 123.54801 0.019607843
zrw ED Pozo Almonte-La 113.5839 zrw ED Pozo Almonte-La Casca 111.312222 ‐0.020408163
xrw GA Domeyko-Lagun 107.6583 xrw GA Domeyko-Laguna Seca 109.811466 0.019607843
rw GA Encuentro-Collah 105.5036 rw GA Encuentro-Collahuasi 106.558636 0.00990099
Figura 13, Comparación de Líneas entre Power World y Digsilent
sistema.
diferencias menores de 3%, al igual que Power World. Se debe mencionar que
Power World – PSS/E y Digsilent nunca supera el 3%, dejando claro que el
programa no es exacto, pero que sí trabaja con un bajo índice de error, creando
61
CAPÍTULO 6.
CONCLUSIONES
de escenarios posibles para poder tomar la mejor decisión, es por esto que las
62
Para probar la efectividad de esta base de datos se comprueban los
para luego hacer los mismos estudios, pero ahora haciendo uso de la
además al hacer uso de Microsoft Excel, los resultados se hacen más claros y
fáciles de chequear.
que este tipo de aplicación necesite evolucionar al mismo ritmo, ya que siempre
tener en cuenta la forma en que los distintos softwares manipulan los datos.
inmenso.
63
Bibliografía
1. Montalván., R. Fuentes. HERRAMIENTAS DE VISUALIZACIÓN DE ESTUDIOS DE FLUJOS DE
POTENCIA PARA EL APOYOA LA TOMA DE DECISIONES EN SISTEMAS ELÉCTRICOS. Universidad
de Chile. Santiago : s.n., 2005. Trabajo de Título.
2. Fast Decoupled Power Flow. B. Slott, O. Alsac. Junio de 1974, IEEE Trans. Power Apparatus
and System.
3. Corporation, Power World. [En línea]
http://www.powerworld.com/features/featurefaq.asp.
4. The MathWorks, Inc. [En línea] http://www.mathworks.com/products/simpower/.
5. SIEMENS. [En línea] http://pssadept.com/pti/PTI‐spanish/software/psse/index‐spanish.cfm.
6. Technologies Inc, RTDS. [En línea] http://www.rtds.com/.
7. Etap, Enterprise Solution for Electrical Power System. [En línea] http://www.etap.com/.
8. GmbH, DIgSILENT. [En línea] http://www.digsilent.com/Software/PowerFactory_Features/.
9. D. T. Risy, and R. H. Staunton. Evaluation of Distribution Analysis Software for DER
Applications. s.l. : ORNL/TM‐2001/215, Sep. 30, 2002.
10. Inc., ABB. [En línea]
http://www.abb.com/Industries/seitp408/05c32a23cb9548e7c1257013003bddb2.aspx.
11. A power system analysis package for students, using computer graphics. Wachal RW,
Tarnawecky MZ, Swift GW. IEEE Trans PAS 1984; PAS‐103(2):445‐8.
12. COPERITE ‐ computer‐aided tool for power engineering research, instruction, training and
education. Chowdhury BH, Clark DE. IEEE Trans Power Syst 1992;7(4):1565‐70.
13. J. D. Glover, M. Sarma. Power System Analysis and Design. 2nd edition. s.l. : PWS Publishing
Company. pág. 253.
14. N. N. Bengiamin, and F. H. Holcomb. PC‐Based Power System Software: Comparing
Functions and Features. s.l. : IEEE Trans. Computer Applications in Power, Jan. 1992. págs. 35‐
40. Vol. no. 1.
15. Modeling Requirements to Study Interactions of DG and Distribution Systems. Kojovic,
Ljubomir. 2002, IEEE‐PES Sumer Meeting.
64
16. Power System Analysis Software Tools. Lokendra Bam, Ward Jewell. 2005, IEEE.
17. Pérez, J. E. Flujos de Potencia Optimo con Programación Secuencial. Universidad de Chile.
Santiago : s.n., 2001. Tésis de Magíster.
18. International, Electrocon. CAPE, El software de ingeniería de protección. [En línea]
http://www.electrocon.com/cape/pf_sp.htm.
19. Saadat, H. Power System Analysis. New York : McGraw‐Hill, 1999.
65
ANEXOS
1. Código Script
El siguiente código es el script que se hizo en este trabajo. Esta en formato DPL
(Digsilent Programming Lenguage).
!-----------------------------------------------------------------------
set Elm,Elm2,Elm3,SBar,Conn,ref,Grids,barras,terminales,prueba;
object pMaq,pStac,pBar,bar1,pGrd,pElm,pElm2,pElm3,pTyp,term,bus,bus1,bus2,bus3,
bus4, bus5,bus6,bus7,bus8,bus9;
string ICONTP,ICONT,TapSide,iZoneBus,IREG,IREGP,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,
s11, s12,s13,s14,s15,s16,s17,s18,s19,s20,s21,s22,s23,s24,s25,s26,s27,s28,s29,s30,
s31,s32,s33,s34,s35,s36,token;
double ZBASE,S_hm,S_hl,S_ml,ISC_hm,ISC_hl,ISC_ml,Req_hm,Req_hl,Req_ml,
Xeq_hm,Xeq_hl,Xeq_ml,Zeq_hm,Zeq_hl,Zeq_ml,RMPCT,rPS,rPT,rST,xPS,xPT,
xST,PG,QG,QT,QB,MBASE,PT,PB,VS,cntrl,ii,aa,bb,cc,dd,ee,ff,MVA,r,r2,r3,x,x2,x3,D1,
D2,D3,D4,D5,D6,D7,D8,D9,D10,D11,D12,D13,D14,D15,D16,D17,D18,D19,D20,
D21,D22,D23,D24,D25,D26,D27,H,unom,unom2,unom3,min_hm,min_hl,min_ml;
int CC,i,j,cont,Tmod,comp,comp2,tok_pos,tok_pos2,numero,k,sPa,c,c2,z,d,comp3,
comp4,comp5;
fopen('C:\Raw.txt','w',0);
Grids = AllRelevant('*.ElmNet');
pGrd = Grids.First();
fprintf(0,'0\tCase Identification Data');
fprintf(0,'IC\tSBASE');
fprintf(0,'0\t100');
!Flujo.Execute();
fprintf(0,'0\tBarras');
fprintf(0,'Name\tStation\tGrid\tNom.L-L Volt.kV\tUl. Magnitude kV\tu. Magnitude p.u\t U.
Angle deg');
fprintf(0,'loc_name\tfold_id\t \te:uknom\tm:Ul\tm:u\tm:phiu');
while (pGrd) { Elm = pGrd.GetContents('*.StaBar',1);
pElm = Elm.First();
while (pElm) { i=pElm.IsRelevant();
if (i=1) { bus1 = pElm.GetParent();
D1 = pElm:m:phiu; !Ángulo Efectivo [º]
D2 = pElm:m:u; !Voltaje Efectivo [p.u.]
D3 = pElm:m:Ul; !Voltaje Efectivo en [kV]
D4 = pElm:uknom; !Voltaje Nominal [kV]
s4 = pElm:loc_name; !Nombre Elemento
s1 = bus1:loc_name; !Nombre Parent
s2 = pGrd:loc_name; !Nombre Grid
fprintf(0,'%s\t%s\t%s\t%.8f\t%g\t%g\t%g',s4,s1,s2,D4,D3,D2,D1);}
pElm = Elm.Next(); }
pGrd = Grids.Next();}
fprintf(0,'0\tTerminales');
fprintf(0,'Name\tParent\tGrid\tNom.L-L Volt.kV\tUl. Magnitude kV\tu. Magnitude p.u\t U.
Angle deg\tOut of Service');
66
fprintf(0,'loc_name\tFold_id\t \te:uknom\tm:Ul\tm:u\tm:phiu\toutserv');
pGrd = Grids.First();
while (pGrd) {Elm = pGrd.GetContents('*.ElmTerm',1);
Elm.SortToVar(0,'outserv');
pElm = Elm.First();
while (pElm) { j=pElm.IsRelevant();
if (j=1) {bus1 = pElm.GetParent();
if (i=0) i=1;
else i=0;
s4 = pElm:loc_name; !Nombre Elemento
s2 = bus1:loc_name; !Nombre Parent
s1 = pGrd:loc_name; !Nombre Grid
i = pElm:outserv; !Estado ON/OFF
if (.not.i) {D1 = pElm:m:phiu; !Ángulo [º]
D2 = pElm:m:u; !Voltaje PSS [p.u.]
D3 = pElm:m:Ul; !Voltaje Efectivo en [kV]
D4 = pElm:uknom; !Voltaje Nominal [kV]
fprintf(0,'%s\t%s\t%s\t%.8f\t%g\t%g\t%g\t%i',s4,s2,s1,D4,D3,D2,D1,i);}
else fprintf(0,'%s\t%s\t%s\t%.8f\t0\t0\t0\t%i',s4,s2,s1,D4,i);}
pElm = Elm.Next(); }
pGrd = Grids.Next();}
fprintf(0,'0\tCargas');
fprintf(0,'Name\tGrid\tType TypLod,TypLodind\tConexion\tTerminal Busbar\tOut of
Service\tAct.Pow. MW\tReact.Pow. Mvar\tApp.Pow. MVA\tI kA\tPow.Fact.');
fprintf(0,'loc_name\t\ttyp_id\tParent\tbus1_bar\toutserv\tplini\tqlini\tslini\tilini\tcoslini');
pGrd = Grids.First();
while (pGrd) {Elm = pGrd.GetContents('*.ElmLod*',1);
Elm.SortToVar(0,'loc_name');
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1) { pTyp=pElm:typ_id;
i=pElm:outserv; !Estado ON/OFF
bus1 = pElm.GetNode(0,0);
bus2 = bus1.GetParent();
s4 = pElm:loc_name; !Nombre Elemento
s1 = pGrd:loc_name; !Nombre Grid
s2 = pTyp:loc_name; !Nombre Tipo
s3 = bus1:loc_name; !Nombre Barra
D1=pElm:plini; !P [MW]
D2=pElm:qlini; !Q [MVar]
D3=pElm:slini; !S [MVA]
D4=pElm:ilini; !I [kA]
D5=pElm:coslini; !fp
s5 = sprintf('%s\t%s\t%s\t%s\t%s',s4,s1,s2,bus2:loc_name,s3);
if (i=1){fprintf(0,'%s\t0\t%f\t%f\t%f\t%f\t%f',s5,D1,D2,D3,D4,D5); }
else{fprintf(0,'%s\t1\t%f\t%f\t%f\t%f\t%f',s5,D1,D2,D3,D4,D5); }}
pElm = Elm.Next();}
pGrd = Grids.Next();}
67
fprintf(0,'0\tGeneradores');
fprintf(0,'Nombre\tGrid\tConexion\tTerminal Busbar\tPG [MW]\tQG [Mvar]\tQT
[Mvar]\tQB [Mvar]\tMBASE [MVA]\tXDSS [p.u]\tService\tPT [MW]\tPB [MW]\tVS
[p.u.]\tIREG Parent\tIREG\tSlack\tRMPCT[%%]');
pGrd = Grids.First();
while (pGrd) {Elm = pGrd.GetContents('*.ElmSym',1);
Elm.SortToVar(0,'outserv');
pElm = Elm.First();
while (pElm) {
j=pElm.IsRelevant();
if (j=1) { i = pElm:outserv;
if (i=1) i=0;
else i=1;
bus1 = pElm.GetNode(0,0);
bus2 = bus1.GetParent(); !Folder Barra i
pTyp=pElm:typ_id;
pStac=pElm:c_pstac; !External Station Controller
s4 = pElm:loc_name; !Nombre Elemento
s1 = pGrd:loc_name; !Nombre Grid
s3 = bus1:loc_name; !Nombre Barra i
s7 = bus2:loc_name; !Nombre Folder Barra
PT=pElm:P_max*pElm:ngnum; !MW max
PB=pElm:P_min; !MW min
MBASE = pTyp:sgn; !MVA Base Generador
if (i=1) { PG=pElm:m:P:bus1; !MW despachados
QG=pElm:m:Q:bus1; !MVar despachados = MVar max = MVar min
if (pStac=NULL) { VS=1; !Voltaje deseado [p.u.]
IREGP=bus2:loc_name; !Nombre Parent Barra a Regular.
IREG=bus1:loc_name; !Nombre Barra a Regular.
RMPCT=100; !Aporte de Reactivos [%] }
else { pBar=pStac:rembar; !IREG
bar1=pBar.GetParent(); !IREG Parent
VS=pStac:usetp; !Voltaje a Regular [p.u.]
IREG=pBar:loc_name; !Nombre Parent Barra a Regular.
IREGP=bar1:loc_name; !Nombre Barra a Regular.
pStac.GetSize('psym',Tmod);
cont = 0;
while (cont<=Tmod) {
pStac.GetVal(pMaq,'psym',cont);
s30=pMaq:loc_name;
if (s30=s4) pStac.GetVal(RMPCT,'cvqq',cont); !Aporte de Reactivos [%]
cont=cont+1; }}
s5=sprintf('%s\t%s\t%s\t%s\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f',s4,s1,s7,s3,PG,QG,QG,QG,M
BASE);
s6=sprintf('%.4f\t%i\t%.3f\t%.3f\t%.3f\t%s\t%s',pTyp:xdss,i,PT,PB,VS,IREGP,IREG);
fprintf(0,'%s\t%s\t%i\t%i',s5,s6,pElm:ip_ctrl,RMPCT);}
else { if (pStac=NULL) { VS=1; !Voltaje deseado [p.u.]
IREGP=bus2:loc_name; !Nombre Parent Barra a Regular.
68
IREG=bus1:loc_name; !Nombre Barra a Regular.
RMPCT=100; !Aporte de Reactivos [%]}
else {pBar=pStac:rembar; !IREG
bar1=pBar.GetParent(); !IREG parent
VS=pStac:usetp; !Voltaje a Regular [p.u.]
IREG=pBar:loc_name; !Nombre Parent Barra a Regular.
IREGP=bar1:loc_name; !Nombre Barra a Regular.
pStac.GetSize('psym',Tmod);
cont = 0;
while (cont<=Tmod) {
pStac.GetVal(pMaq,'psym',cont);
s30=pMaq:loc_name;
if (s30=s4) pStac.GetVal(RMPCT,'cvqq',cont); !Aporte de Reactivos [%]
cont=cont+1; }}
s1=sprintf('%s\t%s\t%s\t%s\t0\t0\t0\t0\t%.3f',s4,s1,s7,s3,MBASE);
s2=sprintf('%.4f\t%i\t%.3f\t%.3f\t%.3f\t%s\t%s',pTyp:xdss,i,PT,PB,VS,IREGP,IREG);
fprintf(0,'%s\t%s\t%i\t%i',s1,s2,pElm:ip_ctrl,RMPCT); }}
pElm = Elm.Next(); }
pGrd = Grids.Next();!-----------------------------------------------------------------LINEAS
pGrd = Grids.First();
fprintf(0,'0\tLineas');
fprintf(0,'Nombre\tGrid L1\tConexion i\tTerminal i\tGrid L2\tConexion j\tTerminal j\tR
[pu]\tX [pu\tB [pu]\tRateA\tRateB\tRateC\tOut of Service\tLen [KM]');
fprintf(0,'loc_name\t\tParent1\tbus1_bar\t\tParent2\tbus2_bar\tR1/dline/MVA\tX1/dline/M
VA\tbline*10^-6*MVA\tMVA\tMVA\tMVA\toutserv\tdline');
while (pGrd) {Elm = pGrd.GetContents('*.ElmLneroute',1);
pElm = Elm.First();
while (pElm) { pTyp = pElm.GetParent();
prueba.Add(pTyp);
pElm = Elm.Next(); }
pGrd = Grids.Next();}
pGrd = Grids.First();
while (pGrd) { Elm = pGrd.GetContents('*.ElmLneroute',1);
pElm = Elm.First();
while (pElm) { j=pElm.IsRelevant();
if (j=1) { bus4 = pElm.GetParent();
i = pElm:outserv;
pTyp = pElm:typ_id;
bus = pElm:bus1;
bus1 = pElm.GetNode(0,0);
bus2 = pElm.GetNode(1,0);
unom = bus.Unom();
MVA=sqrt(3)*unom*pElm:Inom; !MVA Rating para la linea.
D1 = sqr(1000*unom)/100000000; !Impedancia Base.
D2 = pTyp:rline*pElm:dline/D1; !R linea en base común [p.u.].
D3 = pTyp:xline*pElm:dline/D1; !X linea en base común [p.u.].
s4 = pElm:loc_name; !Nombre del Elemento.
s1 = pGrd:loc_name; !Nombre de la Grid.
69
s2 = bus1:loc_name; !Nombre de la Barra i.
s3 = bus2:loc_name; !Nombre de la Barra j.
D4 = pow(10,-6)*pTyp:bline*D1*pElm:dline; !B en PSS.
bus3 = bus1.GetParent();
bus4 = bus2.GetParent();
bus5 = bus3.GetParent();
bus6 = bus4.GetParent();
s7 = bus3:loc_name; !Nombre Parent Barra i.
s8 = bus4:loc_name; !Nombre Parent Barra j.
if (i=0) {s5=sprintf('%f\t%f\t%f\t%.3f\t%.3f\t%.3f',D2,D3,D4,MVA,MVA,MVA);
s6=sprintf('1\t%.2f',pElm:dline);
s9 =sprintf('%s\t%s\t%s\t%s\t%s\t%s\t%s',s4,bus5:loc_name,s7,s2,bus6:loc_name,s8,
s3);
fprintf(0,'%s\t%s\t%s',s9,s5,s6); }
else{s5=sprintf('%.4f\t%.4f\t%.4f\t%.3f\t%.3f\t%.3f',D2,D3,D4,MVA,MVA,MVA);
s6=sprintf('0\t%.2f',pElm:dline);
fprintf(0,'%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s',s4,s1,s7,s8,s2,s3,s5,s6);}}
pElm = Elm.Next();}
pGrd = Grids.Next();}
pGrd = Grids.First();
while (pGrd) { Elm = pGrd.GetContents('*.ElmLne',1);
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1) { bus4 = pElm.GetParent();
i = pElm:outserv;
c = prueba.IsIn(pElm);
if(.not.c) { bus = pElm:bus1;
bus1 = pElm.GetNode(0,0);
bus2 = pElm.GetNode(1,0);
unom = bus.Unom(); !Voltaje nominal en Barra.
MVA=sqrt(3)*unom*pElm:Inom; !MVA rating para la linea.
D1 = sqr(1000*unom)/100000000; !Impedancia Base [p.u.].
D2 = pElm:R1/D1; !R linea en base común.
D3 = pElm:X1/D1; !X linea en base común.
s4 = pElm:loc_name; !Nombre Elemento
s1 = pGrd:loc_name; !Nombre Grid
s2 = bus1:loc_name; !Nombre Barra i
s3 = bus2:loc_name; !Nombre Barra j
bus3 = bus1.GetParent();
bus4 = bus2.GetParent();
bus5 = bus3.GetParent();
bus6 = bus4.GetParent();
s7 = bus3:loc_name; !Nombre Parent Barra i
s8 = bus4:loc_name; !Nombre Parent Barra j
if (pTyp) { D4 = pTyp:bline*pow(10,-6)*D1*pElm:dline; !B en PSS
if (i=0) {s5=sprintf('%.4f\t%.4f\t%.4f\t%.3f\t%.3f\t%.3f',D2,D3,D4,MVA,MVA,MVA);
s6=sprintf('1\t%.2f',pElm:dline);
s9=sprintf('%s\t%s\t%s\t%s\t%s\t%s\t%s',s4,bus5:loc_name,s7,s2,bus6:loc_name,s8,s3);
70
fprintf(0,'%s\t%s\t%s',s9,s5,s6);}
else{s5=sprintf('%.4f\t%.4f\t%.4f\t%.3f\t%.3f\t%.3f',D2,D3,D4,MVA,MVA,MVA);
s6=sprintf('0\t%.2f',pElm:dline);
s9 =sprintf('%s\t%s\t%s\t%s\t%s\t%s\t%s',s4,bus5:loc_name,s7,s2,bus6:loc_name,s8, s3);
fprintf(0,'%s\t%s\t%s',s9,s5,s6); }}
else{s5=sprintf('%.4f\t%.4f\t0\t%.3f\t%.3f\t%.3f',D2,D3,MVA,MVA,MVA);
s6=sprintf('1\t%.2f',pElm:dline);
s9 =sprintf('%s\t%s\t%s\t%s\t%s\t%s\t%s',s4,bus5:loc_name,s7,s2,bus6:loc_name,s8, s3);
fprintf(0,'%s\t%s\t%s',s9,s5,s6); }}}
pElm = Elm.Next();}
pGrd = Grids.Next();}
pGrd = Grids.First();
fprintf(0,'0\tTrafos 2');
fprintf(0,'Nombre\tGrid T1\tConexion i\tTerminal i\tGrid T2\tConexion j\tTerminal j\tR1-2
[pu]\tX1-2 [pu]\tRated Power [MVA]\tRated Power [MVA]\tRated Power [MVA]\tWINDV1
[pu]\tAngle\tOut of Service\tTap Side');
fprintf(0,'loc_name\t\tParent 1\tbus1_bar\t\tParent
2\tbus2_bar\tuktrr/strn\tuktr/strn\tSnom\tSnom\tSnom\tutrn_h/unom\tphitr\toutserv');
pGrd = Grids.First();
while (pGrd) { Elm = pGrd.GetContents('*.ElmTr2',1);
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1) { i=pElm:outserv; !Estado del Trafo (ON/OFF)
if (i=1) i=0;
else i=1;
pTyp=pElm:typ_id;
x=pTyp:uktr/pTyp:strn; !X1-2
r=pTyp:uktrr/pTyp:strn; !R1-2
bus1 = pElm.GetNode(0,0); !Barra i
bus2 = pElm.GetNode(1,0); !Barra j
unom = bus1.Unom(); !Voltaje barra lado alta base propia
unom2 = bus2.Unom(); !Voltaje barra lado alta base propia
if (pElm:t:tap_side=0) { s30=sprintf('HV');
if (pTyp:nt2ag<6) D1=pTyp:utrn_h/unom+(pTyp:dutap/100);
else D1=pTyp:utrn_h/unom-(pTyp:dutap/100);}
else{s30=sprintf('LV');
if (pTyp:nt2ag<6) D1=pTyp:utrn_l/unom2+(pTyp:dutap/100);
else D1=pTyp:utrn_l/unom2-(pTyp:dutap/100); }
D2 = pTyp:nt2ag*30; !Ángulos segun conexión
s4 = pElm:loc_name; !Nombre Trafo
s1 = pGrd:loc_name; !Nombre Grid
s2 = bus1:loc_name; !Nombre Barra i
s3 = bus2:loc_name; !Nombre Barra j
bus3 = bus1.GetParent();
bus4 = bus2.GetParent();
bus5 = bus3.GetParent();
bus6 = bus4.GetParent();
71
s5=sprintf('%.4f\t%.4f\t%.3f\t%.3f\t%.3f\t%g\t%f',r,x,pElm:Snom,pElm:Snom,pElm:Snom
,D1,D2);
s6=sprintf('%i',i);
s7=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus5:loc_name,bus3:loc_name,s2,bus6:loc_na
me,bus4:loc_name);
fprintf(0,'%s\t%s\t%s\t%s\t%s',s7,s3,s5,s6,s30); }
pElm = Elm.Next();}
pGrd = Grids.Next();}
fprintf(0,'0\tTrafos 3');
fprintf(0,'Nombre\tGrid T1\tConexion i\tTerminal i\tGrid T2\tConexion j\tTerminal j\tR1-2
[pu]\tX1-2 [pu]\tRated Power [MVA]\tRated Power [MVA]\tRated Power [MVA]\tWINDV1
[pu]\tAngle\tOut of Service');
fprintf(0,'loc_name\t\tParent 1\tbus1_bar\t\tParent
2\tbus2_bar\tuktrr/strn\tuktr/strn\tSnom\tSnom\tSnom\tutrn_h/unom\tphitr\toutserv');
pGrd = Grids.First();
while (pGrd) {Elm = pGrd.GetContents('*.ElmTr3',1);
Elm.SortToVar(0,'loc_name');
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1) { i = pElm:outserv;
if (i=1) i=0;
else i=1;
pTyp = pElm:typ_id;
min_hm=min(pTyp:strn3_h,pTyp:strn3_m); !Mínimo entre Alta y Media
min_hl=min(pTyp:strn3_h,pTyp:strn3_l); !Mínimo entre Alta y Baja
min_ml=min(pTyp:strn3_l,pTyp:strn3_m); !Mínimo entre Baja y Media
x=pTyp:uktr3_h/min_hm; !X1-2
x2=pTyp:uktr3_m/min_ml; !X2-3
x3=pTyp:uktr3_l/min_hl; !X3-1
r=pTyp:uktrr3_h/min_hm; !R1-2
r2=pTyp:uktrr3_m/min_ml; !R2-3
r3=pTyp:uktrr3_l/min_hl; !R3-1
bus1 = pElm.GetNode(0,0); !Barra Alta
bus2 = pElm.GetNode(1,0); !Barra Media
bus3 = pElm.GetNode(2,0); !Barra Baja
unom = bus1.Unom(); !Voltaje Alta
unom2 = bus2.Unom(); !Voltaje Media
unom3 = bus3.Unom(); !Voltaje Baja
if (pElm:t3ldc=0) {if (pTyp:nt3ag_h<6) D1=pTyp:utrn3_h/unom +(pElm:n3tap_h/100);
else D1=pTyp:utrn3_h/unom -(pElm:n3tap_h/100);
if (pTyp:nt3ag_m<6) D2=pTyp:utrn3_m/unom2+(pElm:n3tap_m/100);
else D2=pTyp:utrn3_m/unom2-(pElm:n3tap_m/100);
if (pTyp:nt3ag_l<6) D3=pTyp:utrn3_h/unom +(pElm:n3tap_h/100);
else D3=pTyp:utrn3_h/unom-(pElm:n3tap_h/100); }
else{if (pElm:t3ldc=1) {if (pTyp:nt3ag_h<6) D1=pTyp:utrn3_m/unom2
+(pElm:n3tap_m/100); !WINDV1/RATIO (PSS)
else D1=pTyp:utrn3_m/unom2 -(pElm:n3tap_m/100);
if (pTyp:nt3ag_m<6) D2=pTyp:utrn3_h/unom+(pElm:n3tap_h/100);
72
else D2=pTyp:utrn3_h/unom-(pElm:n3tap_h/100);
if (pTyp:nt3ag_l<6) D3=pTyp:utrn3_m/unom2 +(pElm:n3tap_m/100);
else D3=pTyp:utrn3_m/unom2 -(pElm:n3tap_m/100); }
else {if (pElm:t3ldc=2) {if (pTyp:nt3ag_h<6) D1=pTyp:utrn3_h/unom
+(pElm:n3tap_h/100);
else D1=pTyp:utrn3_h/unom -(pElm:n3tap_h/100);
if (pTyp:nt3ag_m<6) D2=pTyp:utrn3_l/unom3+(pElm:n3tap_l/100);
else D2=pTyp:utrn3_l/unom3-(pElm:n3tap_l/100);
if (pTyp:nt3ag_l<6) D3=pTyp:utrn3_l/unom3 +(pElm:n3tap_l/100);
else D3=pTyp:utrn3_l/unom3 -(pElm:n3tap_l/100); !WINDV3/RATIO (PSS) }}}
D4 = pTyp:nt3ag_h*30; !Ángulo Alta
D5 = pTyp:nt3ag_m*30; !Ángulo Media
D6 = pTyp:nt3ag_l*30; !Ángulo Baja
s4 = pElm:loc_name; !Nombre Trafo
s1 = pGrd:loc_name; !Nombre Grid
s2 = bus1:loc_name; !Nombre Barra i
s3 = bus2:loc_name; !Nombre Barra j
s7 = bus3:loc_name; !Nombre Barra k
bus4 = bus1.GetParent();
bus5 = bus2.GetParent();
bus6 = bus3.GetParent();
bus7 = bus4.GetParent();
bus8 = bus5.GetParent();
bus9 = bus6.GetParent();
s5=sprintf('%f\t%f\t%.3f\t%.3f\t%.3f\t%g\t%f',r,x,pTyp:strn3_h,pTyp:strn3_h,pTyp:strn3_
h,D1,D4);
s6=sprintf('%i',i);
s8=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus7:loc_name,bus4:loc_name,s2,bus8:loc_na
me,bus5:loc_name);
fprintf(0,'%s\t%s\t%s\t%s',s8,s3,s5,s6);! Trafo i-j
s5=sprintf('%f\t%f\t%.3f\t%.3f\t%.3f\t%g\t%f',r2,x2,pTyp:strn3_m,pTyp:strn3_m,pTyp:str
n3_m,D2,D5);
s6=sprintf('%i',i);
s8=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus8:loc_name,bus5:loc_name,s3,bus9:loc_na
me,bus6:loc_name);
fprintf(0,'%s\t%s\t%s\t%s',s8,s7,s5,s6);! Trafo j-k
s5=sprintf('%f\t%f\t%.3f\t%.3f\t%.3f\t%g\t%f',r3,x3,pTyp:strn3_l,pTyp:strn3_l,pTyp:strn3
_l,D3,D6);
s6=sprintf('%i',i);
s8=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus7:loc_name,bus4:loc_name,s2,bus9:loc_na
me,bus6:loc_name);
fprintf(0,'%s\t%s\t%s\t%s',s8,s7,s5,s6);! Trafo i-k }
pElm = Elm.Next(); }
pGrd = Grids.Next();}
pGrd = Grids.First();
fprintf(0,'0\tTrafos 2 & 3');
fprintf(0,'Nombre\tGrid T1\tConexion i\tTerminal i\tGrid T2\tConexion j\tTerminal
j\tRMA\tRMI\tVMA\tVMI\tSTEP\tTABLE\tCNTRL\tCR\tCX');
73
while (pGrd) {Elm = pGrd.GetContents('*.ElmTr2',1);
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1){ i = pElm:outserv;
if (i=0) { i=1;
pTyp = pElm:typ_id;
if (pElm:t:tap_side=0) {aa=pTyp:utrn_h/unom+(pTyp:dutap/100);
bb=pTyp:utrn_h/unom-(pTyp:dutap/100);
cc = pElm:n:u:bushv;
dd = pElm:n:u:bushm;}
else{aa=pTyp:utrn_l/unom2+(pTyp:dutap/100);
bb=pTyp:utrn_l/unom2-(pTyp:dutap/100);
cc = pElm:n:u:bushv;
dd = pElm:n:u:bushm; }
ee=pTyp:dutap/100; !STEP Tap PSS
cntrl=0; !CNTRL
ff=0; !TABLE
bus1 = pElm.GetNode(0,0);
bus2 = pElm.GetNode(1,0);
s1 = pGrd:loc_name; !Nombre Grid
s2 = bus1:loc_name; !Nombre Barra i
s3 = bus2:loc_name; !Nombre Barra j
s4 = pElm:loc_name; !Nombre Trafo
bus3 = bus1.GetParent();
bus4 = bus2.GetParent();
bus5 = bus3.GetParent();
bus6 = bus4.GetParent();
s6=sprintf('%.4f\t%.4f\t%.4f\t%.4f\t%.5f\t%.4f',aa,bb,cc,dd,ee,ff);
s9=sprintf('%s\t%d\t%d\t%d',s6,cntrl,ff,ff);
s7=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus5:loc_name,bus3:loc_name,s2,bus6:loc_na
me,bus4:loc_name);
fprintf(0,'%s\t%s\t%s',s7,s3,s9); }
else i=0; }
pElm = Elm.Next();}
pGrd = Grids.Next();}
pGrd = Grids.First();
while (pGrd) {cntrl=0;
ff=0;
Elm = pGrd.GetContents('*.ElmTr3',1);
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1) { i = pElm:outserv;
if (i=0) {i=1;
pTyp = pElm:typ_id;
bus1 = pElm.GetNode(0,0);
bus2 = pElm.GetNode(1,0);
bus3 = pElm.GetNode(2,0);
bus4 = bus1.GetParent();
74
bus5 = bus2.GetParent();
bus6 = bus3.GetParent();
bus7 = bus4.GetParent();
bus8 = bus5.GetParent();
bus9 = bus6.GetParent();
unom = bus1.Unom(); !Voltaje Alta
unom2 = bus2.Unom(); !Voltaje Media
unom3 = bus3.Unom(); !Voltaje Baja
s1 = pGrd:loc_name; !Nombre Grid
s2 = bus1:loc_name; !Nombre Terminal i
s3 = bus2:loc_name; !Nombre Terminal j
s7 = bus3:loc_name; !Nombre Terminal k
s4 = pElm:loc_name; !Nombre Trafo
if (pTyp:nt3ag_h<6) { aa=pTyp:utrn3_h/unom +(pElm:n3tap_h/100);
bb=pTyp:utrn3_h/unom -(pElm:n3tap_h/100);}
else if (pTyp:nt3ag_m<6) {aa=pTyp:utrn3_m/unom2+(pElm:n3tap_m/100);
bb=pTyp:utrn3_m/unom2-(pElm:n3tap_m/100); !WINDV2/RATIO (PSS) }
cc=pElm:n:u:bushv; !VMA PSS
dd=pElm:n:u:bushv; !VMI PSS
ee=pTyp:du3tp_h/100; !STEP Tap PSS
s5=sprintf('%.4f',r);
s6=sprintf('%.4f\t%.4f\t%.4f\t%.4f\t%.5f\t%.4f',aa,bb,cc,dd,ee,ff);
s9=sprintf('%s\t%d\t%d\t%d',s6,cntrl,ff,ff);
s8=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus7:loc_name,bus4:loc_name,s2,bus8:loc_na
me,bus5:loc_name);
fprintf(0,'%s\t%s\t%s',s8,s3,s9);
if (pTyp:nt3ag_h<6) { aa=pTyp:utrn3_h/unom +(pElm:n3tap_h/100);
bb=pTyp:utrn3_h/unom -(pElm:n3tap_h/100); }
else if (pTyp:nt3ag_l<6) {aa=pTyp:utrn3_l/unom3+(pElm:n3tap_l/100);
bb=pTyp:utrn3_l/unom3-(pElm:n3tap_l/100); !WINDV2/RATIO (PSS) }
cc=pElm:n:u:busmv; !VMA PSS
dd=pElm:n:u:busmv; !VMI PSS
ee=pTyp:du3tp_m/100; !STEP Tap PSS
s5=sprintf('%.4f',r2);
s6=sprintf('%.4f\t%.4f\t%.4f\t%.4f\t%.5f\t%.4f',aa,bb,cc,dd,ee,ff);
s9=sprintf('%s\t%d\t%d\t%d',s6,cntrl,ff,ff);
s8=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus8:loc_name,bus5:loc_name,s3,bus9:loc_na
me,bus6:loc_name);
fprintf(0,'%s\t%s\t%s',s8,s7,s9);
if (pTyp:nt3ag_m<6) {aa=pTyp:utrn3_m/unom2 +(pElm:n3tap_m/100);
bb=pTyp:utrn3_m/unom2 -(pElm:n3tap_m/100); }
else if (pTyp:nt3ag_l<6) {aa=pTyp:utrn3_l/unom3+(pElm:n3tap_l/100);
bb=pTyp:utrn3_l/unom3-(pElm:n3tap_l/100); !WINDV2/RATIO (PSS) }
cc=pElm:n:u:buslv; !VMA PSS
dd=pElm:n:u:buslv; !VMI PSS
ee=pTyp:du3tp_l/100; !STEP Tap PSS
s5=sprintf('%.4f',r3);
s6=sprintf('%.4f\t%.4f\t%.4f\t%.4f\t%.5f\t%.4f',aa,bb,cc,dd,ee,ff);
75
s9=sprintf('%s\t%d\t%d\t%d',s6,cntrl,ff,ff);
s8=sprintf('%s\t%s\t%s\t%s\t%s\t%s',s4,bus7:loc_name,bus4:loc_name,s2,bus9:loc_na
me,bus6:loc_name);
fprintf(0,'%s\t%s\t%s',s8,s7,s9);}
else i=0; }
pElm = Elm.Next(); }
pGrd = Grids.Next();}
fprintf(0,'0\tShunts');
fprintf(0,'Name\tGrid\tConexion\tTerminal BusBar\tUpper Voltage Limit [pu]\tLower
Voltage Limit [pu]\tBinit\tNi\tBi');
fprintf(0,'loc_name\t\tParent\tbus1_bar\tusetp_mx\tusetp_mn\tncapa(qcapn-
qrean)\tncapx\Qmax/ncapx');
pGrd = Grids.First();
while (pGrd) {Elm = pGrd.GetContents('*.ElmShnt',1);
pElm = Elm.First();
while (pElm) { j=pElm.IsRelevant();
if (j=1) { bus1 = pElm.GetNode(0,0);
bus2 = bus1.GetParent();
D1=pElm:n:u:bus1; !VSWHI PSS
D2=pElm:n:u:bus1; !VSWLO PSS
D3=pElm:ncapa*(pElm:qrean-pElm:qcapn); !BINIT en PSS/Power World
D4=pElm:ncapx; !N1 en PSS
D5=pElm:Qmax/pElm:ncapx; !B1 en PSS
s4=pElm:loc_name; !Nombre Elemento
s1=pGrd:loc_name; !Nombre Grid
s2=bus1:loc_name; !Nombre Barra i
s3=bus2:loc_name; !Nombre Barra j
s5=sprintf('%g\t%g\t%g\t%i',D1,D2,D3,D4);
if (pElm:qcapn > 0) {s6=sprintf('%g',D5);
fprintf(0,'%s\t%s\t%s\t%s\t%s\t%s',s4,s1,s3,s2,s5,s6); }
else {s7=sprintf('-%g',D5);
fprintf(0,'%s\t%s\t%s\t%s\t%s\t%s',s4,s1,s3,s2,s5,s7); }}
pElm = Elm.Next();}
pGrd = Grids.Next(); }
pGrd = Grids.First();
fprintf(0,'0\tSwitchs Abiertos');
fprintf(0,'Nombre\tGrid\tParent\tElemento conectado1\tGrid2\tParent2\tElemento
Conectado2\tTipo de elemento\tEstado');
fprintf(0,'loc_name\t\tFold_id1\tbus1\t\tFold_id2\tbus2\tGetClass\ton_off');
while (pGrd) { Elm = pGrd.GetContents('*.ElmCoup',1);
Elm.SortToVar(0,'on_off','loc_name');
pElm = Elm.First();
while (pElm) {c=pElm.IsRelevant();
if (c=1) {bus1 = pElm.GetNode(0,0);
bus2 = pElm.GetNode(1,0);
bus3 = bus1.GetParent();
bus4 = bus3.GetParent();
bus5 = bus2.GetParent();
76
bus6 = bus5.GetParent();
s1 = pElm:loc_name;
s2 = bus1:loc_name;
s3 = bus2:loc_name;
s4 = bus3:loc_name;
s5 = bus4:loc_name;
s6 = bus5:loc_name;
s7 = bus6:loc_name;
s8 = pGrd:loc_name;
i = pElm:on_off;
fprintf(0,'%s\t%s\t%s\t%s\t%s\t%s\t%s\t0\t%i',s1,s5,s4,s2,s7,s6,s3,i);}
pElm = Elm.Next(); }
pGrd = Grids.Next(); }
pGrd = Grids.First();
while (pGrd) {Elm = pGrd.GetContents('*.StaSwitch',1);
Elm.SortToVar(0,'on_off','loc_name');
pElm = Elm.First();
while (pElm) { c=pElm.IsRelevant();
if (c=1) {Elm2 = pElm.GetConnectedElms(1,1,1);
d = Elm2.Count();
bus1 = pElm.GetParent();
bus2 = bus1.GetParent();
bus5 = Elm2.First();
cont = 0;
while(bus5) {s1 = pElm:loc_name;
s2 = bus2:loc_name;
s4 = bus5.GetClass();
s8 = pGrd:loc_name;
s9 = bus5:loc_name;
bus9 =bus5.GetParent();
bus8 = bus9.GetParent();
s10 = '';
i = pElm:on_off;
j = pElm:iUse;
if (d=2) {if (cont = 0) {if (j = 6) {bus4 = bus2.GetParent();
s3 = bus4:loc_name;
s5 = sprintf('%s\t%s\t%s\t%s',s1,s8,bus9:loc_name,s9);
cont = 1; }
else{ bus4 = bus2.GetParent();
s3 = bus4:loc_name;
s5 = sprintf('%s\t%s\t%s\t%s',s1,s8,bus9:loc_name,s9);
cont = 1;}}
else {if (j = 6) {s1 = bus9:loc_name;
s6 = sprintf('%s\t%s\t%s\t%i',s1,s9,s4,i);
cont = 0; }
else{ bus3 = bus1:obj_id;
bus4 = bus3.GetParent();
bus9 = bus4.GetParent();
77
s1 = bus3:loc_name;
s2 = bus4:loc_name;
s3 = bus9:loc_name;
if (bus3) s6= sprintf('%s\t%s\t%s\t%i',s2,s1,s4,i);
else s6 = sprintf('%s\t%s\t%s\t%s\t%i',s8,s10,s10,i);
cont = 0;}
fprintf(0,'%s\t%s\t%s',s5,bus8:loc_name,s6);} }
else fprintf(0,'%s\t%s\t%s\t%s\t0\t0\t0\t0\t0',s1,s8,bus9:loc_name,s9);
bus5 = Elm2.Next();} }
pElm = Elm.Next();}
pGrd = Grids.Next();}
fclose(0);
fopen('C:\seq.txt','w',1);
pGrd = Grids.First();
fprintf(1,'0\tPositive Sequence Generator Impedance Data');
fprintf(1,'Terminal Bus Bar\tName\tZRPOS [pu]\tZXPOS [pu]');
fprintf(1,'bus1_bar\tloc_name\trstr\txdss');
Elm=pGrd.GetContents('*.ElmSym',1);
pElm=Elm.First();
while (pElm) { j=pElm.IsRelevant();
if (j=1) {s4 = pElm:loc_name; !Nombre Elemento
pTyp = pElm:typ_id;
bus1 = pElm.GetNode(0,0);
if (pTyp) {s1 = bus1:loc_name; !Nombre Barra i
fprintf(1,'%s\t%s\t%.5f\t%.5f',s1,s4,pTyp:rstr,pTyp:xdss); }
else {fprintf(1,'%s',s4);
s1 = bus1:loc_name; !Nombre Barra i
fprintf(1,'%s\t%s\t###\t###',s1,s4); }}
pElm = Elm.Next();}
fprintf(1,'0\tNegative Sequence Generator Impedance Data');
fprintf(1,'Terminal Bus Bar\tName\tZRNEG [pu]\tZXNEG [pu]');
fprintf(1,'bus1_bar\tloc_name\tr2sy\tx2sy');
pGrd = Grids.First();
Elm = pGrd.GetContents('*.ElmSym',1);
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1) {pTyp = pElm:typ_id;
bus1 = pElm.GetNode(0,0);
s4 = pElm:loc_name; !Nombre Elemento
s1 = bus1:loc_name; !Nombre Barra i
if (pTyp) fprintf(1,'%s\t%s\t%.5f\t%.5f',s1,s4,pTyp:r2sy,pTyp:x2sy);
else fprintf(1,'%s\t\t###\t###%s',s1,s4); }
pElm = Elm.Next();}
fprintf(1,'0\tZero Sequence Generator Impedance Data');
fprintf(1,'Terminal Bus Bar\tName\tRZERO [pu]\tXZERO[pu]');
fprintf(1,'bus1_bar\tloc_name\tr0sy\tx0sy');
pGrd = Grids.First();
Elm = pGrd.GetContents('*.ElmSym',1);
78
pElm = Elm.First();
while (pElm) {j=pElm.IsRelevant();
if (j=1) {pTyp = pElm:typ_id;
bus1 = pElm.GetNode(0,0);
s4 = pElm:loc_name;
s1 = bus1:loc_name;
if (pTyp) fprintf(1,'%s\t%s\t%.5f\t%.5f',s1,s4,pTyp:r0sy,pTyp:x0sy);
else fprintf(1,'%s\t%s\t###\t###',s1,s4); }
pElm = Elm.Next();}
fprintf(1,'0\tNegative Sequence Shunt Load Data');
fprintf(1,'0\tZero Sequence Shunt Load Data');
fprintf(1,'0\tZero Sequence Branch Data');
fprintf(1,'Name\tTerminal i Bus bar\tTerminal j Bus Bar\tRLINZ\tXLINZ\tBCHZ');
fprintf(1,'loc_name\tbus1_bar\tbus2_bar\t(R0/dline)/(unom^2/MVA)\t(X0/dline)/(unom^2/
MVA)\t(bline0)/(unom^2/MVA)');
pGrd = Grids.First();
Elm = pGrd.GetContents('*.ElmLne');
pElm = Elm.First();
while (pElm) { j=pElm.IsRelevant();
if (j=1) {pTyp = pElm:typ_id;
bus = pElm:bus1;
unom = bus.Unom();
bus1 = pElm.GetNode(0,0);
bus2 = pElm.GetNode(1,0);
s4 = pElm:loc_name;
s1 = bus1:loc_name;
s2 = bus2:loc_name;
if (pTyp) {D1 = sqr(unom*1000)/100000000;
D2 = pElm:R0/D1;
D3 = pElm:X0/D1;
D4 = pTyp:bline0/D1;
fprintf(1,'%s\t%s\t%s\t%.5f\t%.5f\t%.5f',s1,s2,s4,D2,D3,D4); }
else {fprintf(1,'%s\t%s\t%s\t%.5f\t%.5f\t0',s1,s2,s4,D2,D3);} }
pElm = Elm.Next();}
fprintf(1,'0\tZero Sequence Mutual Impedance Data');
fprintf(1,'0\tTransformer 2 Grounding Code Data');
fprintf(1,'Name\tTerminal i Bus bar\tTerminal j Bus Bar\tGrounding Code I\tGrounding
Code J');
fprintf(1,'loc_name\tbus1_bar\tbus2_bar\ttr2cn:h\ttr2cn_l');
pGrd = Grids.First();
Elm = pGrd.GetContents('*.ElmTr2');
pElm = Elm.First();
while (pElm) { c=pElm.IsRelevant();
if (c=1) {pTyp = pElm:typ_id;
r=pTyp:ur0tr/pTyp:strn; !R seq cero
x=pTyp:uk0tr/pTyp:strn; !x seq cero
s1 = pTyp:tr2cn_h; !tipo de conexion en alta
s2 = pTyp:tr2cn_l; !tipo de conexion en baja
79
bus1 = pElm.GetNode(0,0); !conexion i
bus2 = pElm.GetNode(1,0); !conexion j
s4 = pElm:loc_name; !Nombre Trafo
s5 = bus1:loc_name; !nombre barra i
s6 = bus2:loc_name; !Nombre Barra j
i=strcmp(s1,'Y',2);
j=strcmp(s2,'Y',2);
if(i=0 .or. i=1) {if (j=0 .or. j=1) fprintf(1,'%s\t%s\t%s\t1\t1',s4,s5,s6);
else fprintf(1,'%s\t%s\t%s\t1\t0',s4,s5,s6); }
else{if (j=0 .or. j=1) fprintf(1,'%s\t%s\t%s\t0\t1',s4,s5,s6);
else fprintf(1,'%s\t%s\t%s\t0\t0',s4,s5,s6); }}
pElm = Elm.Next(); }
fprintf(1,'0\tTransformer 3 Grounding Code Data');
fprintf(1,'Name\tTerminal i Bus bar\tTerminal j Bus Bar\tGrounding Code I\tGrounding
Code J');
fprintf(1,'loc_name\tbus1_bar\tbus2_bar\ttr2cn:h\ttr2cn_l');
pGrd = Grids.First();
while (pGrd) {Elm = pGrd.GetContents('*.ElmTr3',1);
pElm = Elm.First();
while (pElm) {pTyp = pElm:typ_id;
s1 = pTyp:tr3cn_h;
s5 = pTyp:tr3cn_m;
s6 = pTyp:tr3cn_l;
i=strcmp(s1,'Y',2);
j=strcmp(s5,'Y',2);
k=strcmp(s6,'y',2);
bus1 = pElm.GetNode(0,0); !barra alta tension
bus2 = pElm.GetNode(1,0); !barra media
bus3 = pElm.GetNode(2,0); !barra baja
s4 = pElm:loc_name;
s2 = bus1:loc_name;
s3 = bus2:loc_name;
s7 = bus3:loc_name;
if(i=0 .or. i=1) {if (j=0 .or. j=1) fprintf(1,'%s\t%s\t%s\t1\t1',s2,s3,s4);
else fprintf(1,'%s\t%s\t%s\t1\t0',s2,s3,s4); }
else{if (j=0 .or. j=1) fprintf(1,'%s\t%s\t%s\t0\t1',s2,s3,s4);
else fprintf(1,'%s\t%s\t%s\t0\t0',s2,s3,s4); }
if(j=0 .or. j=1) {if (k=0 .or. k=1) fprintf(1,'%s\t%s\t%s\t1\t1',s3,s7,s4);
else fprintf(1,'%s\t%s\t%s\t1\t0',s3,s7,s4); }
else{if (k=0 .or. k=1) fprintf(1,'%s\t%s\t%s\t0\t1',s3,s7,s4);
else fprintf(1,'%s\t%s\t%s\t0\t0',s3,s7,s4); }
if(i=0 .or. i=1) {if (k=0 .or. k=1) fprintf(1,'%s\t%s\t%s\t1\t1',s2,s7,s4);
else fprintf(1,'%s\t%s\t%s\t1\t0',s2,s7,s4); }
else{if (k=0 .or. k=1) fprintf(1,'%s\t%s\t%s\t0\t1',s2,s7,s4);
else fprintf(1,'%s\t%s\t%s\t0\t0',s2,s7,s4); }
pElm = Elm.Next();}
pGrd = Grids.Next();}
fprintf(1,'0\tZero Sequence Switched Shunt Data');
80
fclose(1);
fopen('C:\DYR.txt','w',2);
fprintf(2,'0\tModelo Generadores');
fprintf(2,'Nombre\tTerminal Bus Bar\tH [s]\tDamp [pu]\trstr [pu]\txl [pu]\txrl [pu]\tRotor
Type\txd [pu]\txq [pu]\tTd0´ [s]\tTq0´ [s]\txd´ [pu]\txq´ [pu]\tTd0´´ [s]\tTq0´´ [s]\txd´´
[pu]\txq´´ [pu]\tMain Flux Saturation\t1.0 [pu]\t1.2 [pu]');
fprintf(2,'loc_name\tbus1_bar\th\tdpu\trstr\txl\txrl\titurbo\txd\txq\ttds0\ttqs0\txds\txqs\ttds
s0\ttqss0\txdss\txqss\tisat\tsg10\tsg12');
pGrd = Grids.First();
while (pGrd) { Elm = pGrd.GetContents('*.ElmSym',1);
Elm.SortToVar(1,'c_pmod');
pElm = Elm.First();
while (pElm) { c=pElm.IsRelevant();
if (c=1) { pTyp = pElm:typ_id;
bus1 = pElm.GetNode(0,0);
s4 = pElm:loc_name;
s3 = bus1:loc_name;
D1 = pTyp:h; !constante de tiempo de inercia
D2 = pTyp:dpu; !liberacion de carga mecanica
D3 = pTyp:rstr; !resistencia estator
D4 = pTyp:xl; !reactancia de fuga estator
D5 = pTyp:xrl; !reactancia de fuga rotor
D6 = pTyp:xd; !reactancia sincronica en eje directo
D7 = pTyp:xq; !reactancia sincronica en eje quadratura
D8 = pTyp:tds0; !constante de tiempo transiente eje directo
D9 = pTyp:tqs0; !constante de tiempo transiente eje cuadratura
D10 = pTyp:xds; !reactancia transiente eje directo
D11 = pTyp:xqs; !reactancia transiente eje cuadratura
D12 = pTyp:tdss0; !constante de tiempo subtransiente eje directo
D13 = pTyp:tqss0; !constante de tiempo subtransiente eje cuadratura
D14 = pTyp:xdss; !reactancia subtransiente eje directo
D15 = pTyp:xqss; !reactancia subtransiente eje cuadratura
D16 = pTyp:sg10; !parametro de stauracion 1.0
D17 = pTyp:sg12; !parametro de stauracion 1.2
i = pTyp:iturbo; !tipo de rotor (polos salientes o
j = pTyp:isat; !saturacion flujo principal
s5=sprintf('%s\t%s\t%g\t%g\t%g\t%g\t%g\t%i\t%g',s4,s3,D1,D2,D3,D4,D5,i,D6);
s6=sprintf('%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g',D7,D8,D9,D10,D11,D12,D13,D14,D
15);
fprintf(2,'%s\t%s\t%i\t%g\t%g',s5,s6,j,D16,D17); }
pElm = Elm.Next();}
pGrd = Grids.Next(); }
pGrd = Grids.First();
fprintf(2,'0\tModelo VCO Generadores');
pGrd = Grids.First();
while (pGrd) { Elm = pGrd.GetContents('*.ElmSym',1);
Elm.SortToVar(1,'c_pmod');
pElm = Elm.First();
81
while (pElm) { pElm2 = pElm:c_pmod; !Modelo de Planta
if (pElm2) {pElm2.GetSize('pblk',Tmod);
cont = 0;
while (cont<Tmod) {pElm2.GetVal(pElm3,'pblk',cont);
s1 = pElm3:loc_name;
comp = strcmp(s1,'vco',3);
comp2 = strcmp(s1,'AVR',3);
token = ',';
if (comp = 0 .or. comp2 = 0) {pElm2.GetVal(term,'pelm',cont);
if (term) {pTyp = term:typ_id;
s2 = term:loc_name;
if (pTyp) {term.GetSize('params',sPa);
r = 0;
sPa+=1;
while (r<sPa) {c = 0;
s3 = pTyp:sParams;
s30 = pTyp:sUpLimPar;
s31 = pTyp:sLowLimPar;
s32 = '';
s33 = '';
while (c<=sPa) {term.GetVal(D1,'params',c);
s4 = strtok(s3,token,tok_pos,c+1);
i = strcmp(s4,'');
if (i=1) {s33 = sprintf('%s\t%g',s33,D1);
if (c=0) s32 = sprintf('%s',s4);
else s32 = sprintf('%s\t%s',s32,s4); }
else break;
c+=1; }
c2 = c;
c=0;
z = strcmp(s30,'');
d = strcmp(s31,'');
if (d) {while (c<sPa) {term.GetVal(D1,'params',c2);
s5 = strtok(s31,token,tok_pos,c+1);
i = strcmp(s5,'');
if (i=1) {s33 = sprintf('%s\t%g',s33,D1);
s32 = sprintf('%s\t%s',s32,s5); }
else break;
c2+=1;
c+=1; }}
c=0;
if (z) {while (c<sPa) {term.GetVal(D1,'params',c2);
s6 = strtok(s30,token,tok_pos,c+1);
i = strcmp(s6,'');
if (i=1) {s33 = sprintf('%s\t%g',s33,D1);
s32 = sprintf('%s\t%s',s32,s6); }
else break;
c2+=1;
82
c+=1; }}
fprintf(2,'%s\t%s',term:loc_name,s32);
fprintf(2,'%s\%s',pElm:loc_name,s33);
break;
r+=1; }}
else{fprintf(2,'VCO_%s\ttvm\tvspp\ttspi\tur_mx\tur_mn\tterr\tvss\ttst\tefdmx\tefdmn\tkur\t
kui\tkir\tkii\tib_sl',pElm:loc_name);
s7 = sprintf('%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g',pElm:loc_name,term:tvm,
term:vspp,term:tspi,term:ur_mx,term:ur_mn,term:terr,term:vss,term:tst);
fprintf(2,'%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g',s7,term:efdmx,term:efdmn,term:kur,term:k
ui,term:kir,term:kii,term:ib_sl); }}
else {fprintf(2,'%s',pElm:loc_name);
fprintf(2,'Sin VCO'); }}
cont +=1; } }
else{fprintf(2,'Sin Modelo');
fprintf(2,'%s',pElm:loc_name); }
pElm = Elm.Next();}
pGrd = Grids.Next(); }
pGrd = Grids.First();
fprintf(2,'0\tModelo Regulador de Turbina');
while (pGrd) {Elm = pGrd.GetContents('*.ElmSym',1);
Elm.SortToVar(1,'c_pmod');
pElm = Elm.First();
while (pElm) {pElm2 = pElm:c_pmod;
if (pElm2) {pElm2.GetSize('pblk',Tmod);
cont = 0;
while (cont<Tmod) {
pElm2.GetVal(pElm3,'pblk',cont);
s1 = pElm3:loc_name;
comp = strcmp(s1,'pcu',3);
comp2 = strcmp(s1,'pmu',3);
comp3 = strcmp(s1,'pco',3);
comp4 = strcmp(s1,'GT',2);
comp5 = strcmp(s1,'ST',2);
token = ',';
if (comp=0 .or. comp2=0 .or. comp3=0 .or. comp4=0 .or. comp5=0) {
pElm2.GetVal(term,'pelm',cont);
if (term) {pTyp = term:typ_id;
s2 = term:loc_name;
if (pTyp) {term.GetSize('params',sPa);
r = 0;
while (r<sPa) {c = 0;
s3 = pTyp:sParams;
s30 = pTyp:sUpLimPar;
s31 = pTyp:sLowLimPar;
s32 = '';
s33 = '';
while (c<=sPa) {term.GetVal(D1,'params',c);
83
s4 = strtok(s3,token,tok_pos,c);
i = strcmp(s4,'');
if (i) {j = strcmp(s32,'');
s33 = sprintf('%s\t%g',s33,D1);
if (.not.j) s32 = sprintf('%s',s4);
else s32 = sprintf('%s\t%s',s32,s4);}
c+=1; }
c=0;
z = strcmp(s30,'');
d = strcmp(s31,'');
if (d) {while (c<sPa) {s5 = strtok(s31,token,tok_pos,c);
i = strcmp(s5,'');
if (i) {s33 = sprintf('%s\t%g',s33,D1);
s32 = sprintf('%s\t%s',s32,s5); }
c+=1; }}
c=0;
if (z) {while (c<sPa) {s6 = strtok(s30,token,tok_pos,c);
i = strcmp(s6,'');
if (i) {s33 = sprintf('%s\t%g',s33,D1);
s32 = sprintf('%s\t%s',s32,s6); }
c+=1; }}
fprintf(2,'%s\t%s',term:loc_name,s32);
fprintf(2,'%s\%s',pElm:loc_name,s33);
break;
r+=1; }}
else{if (comp3 = 0) {d = term.VarExists('w_');
if (d) {fprintf(2,'PCO_%s\tw_ [pu]\tx_ [s]\ty_ [s]\tz_
[pu]\tetd\ttrate\ttdel\tpc_mx [pu]\tpc_mn [pu]\tecr\tk3 [pu]\ta_ [pu]\tb_ [s]\tc_ [pu]\ttauf
[s]\tkf [pu]\tk5 [pu]\tk4 [pu]\tt3 [pu]\tt4 [pu]\ttaut [s]\tt5[pu]\taf1 [pu]\tbf1 [pu]\tthetr [s]\tk6
[pu]',pElm:loc_name);
s7 = printf('%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g',pElm:loc_name,term:w_,term:x_,
term:y_,term:z_,term:etd,term:trate,term:tdel,term:pc_mx);
s8 = sprintf('%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g',s7,term:pc_mn,term:ecr,term:k3,
term:a_,term:b_,term:c_,term:tauf,term:kf);
s9 = sprintf('%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g',s8,term:k5,term:k4,term:t3,term:t4,
term:taut,term:t5,term:af1,term:bf1);
fprintf(2,'%s\t%g\t%g',s9,term:thetr,term:k6); }
else{d = term.VarExists('tp');
if (d) {fprintf(2,'PCO_%s\tdband [pu]\tbp [%%]\tbt [%%]\ttp [s]\ttd [s]\ttr
[s]\tty [s]\tty0 [s]\ttyc [s]\tyt_mx [pu]\tyt_mn [pu]',pElm:loc_name);
s7 = sprintf('%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g',pElm:loc_name,term:dband,
term:bp,term:bt,term:tp,term:td,term:tr,term:ty,term:tyo);
fprintf(2,'%s\t%g\t%g\t%g',s7,term:tyc,term:yt_mx,term:yt_mn); }
else{fprintf(2,'PCO_%s\tdband [pu]\tbp [%%]\tbt [%%]\ttf [s]\ttr [s]\tty [s]\tty0 [s]\ttyc
[s]\tyt_mx [pu]\tyt_mn [pu]',pElm:loc_name);
s7 = sprintf('%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g',pElm:loc_name,term:dband,term:bp,
term:bt,term:tf,term:tr,term:ty,term:tyo);
fprintf(2,'%s\t%g\t%g\t%g',s7,term:tyc,term:yt_mx,term:yt_mn); }}}
84
if (comp2 = 0) {d = term.VarExists('tcd');
if (d) {fprintf(2,'PMU_%s\ttcd [s]\taf2 [pu]\tbf2 [pu]\tcf2 [pu]',pElm:loc_name);
fprintf(2,'%s\t%g\t%g\t%g\t%g',pElm:loc_name,term:tcd,term:af2,term:bf2,term:cf2); }
else{d = term.VarExists('tw');
if (d) {fprintf(2,'PMU_%s\ttw [s]',pElm:loc_name);
fprintf(2,'%s\t%g',pElm:loc_name,term:tw); }
else{fprintf(2,'PMU_%s\tthd [s]\ttmd [s]\ttnd [s]\talfhd [pu]\talfnd [pu]\ttisp
[s]',pElm:loc_name);
fprintf(2,'%s\t%g\t%g\t%g\t%g\t%g\t%g',pElm:loc_name,term:thd,term:tmd,term:tnd,ter
m:alfhd,term:alfnd,term:tisp); }}}}}
else {fprintf(2,'%s',pElm:loc_name);
fprintf(2,'Sin Regulador de Turbina'); }}
cont +=1; }}
else{fprintf(2,'Sin Modelo');
fprintf(2,'%s',pElm:loc_name); }
pElm = Elm.Next(); }
pGrd = Grids.Next();}
pGrd = Grids.First();
fprintf(2,'0\tModelo Estabilizadores de Potencia');
while (pGrd) {Elm = pGrd.GetContents('*.ElmSym',1);
Elm.SortToVar(1,'c_pmod');
pElm = Elm.First();
while (pElm) {pElm2 = pElm:c_pmod;
if (pElm2) {pElm2.GetSize('pblk',Tmod);
cont = 0;
while (cont<Tmod) {pElm2.GetVal(pElm3,'pblk',cont);
s1 = pElm3:loc_name;
comp = strcmp(s1,'pss',3);
comp2 = strcmp(s1,'PSS',3);
token = ',';
if (comp = 0 .or. comp2 = 0) {pElm2.GetVal(term,'pelm',cont);
if (term) {pTyp = term:typ_id;
s2 = term:loc_name;
if (pTyp) {term.GetSize('params',sPa);
r = 0;
while (r<sPa) {c = 0;
s3 = pTyp:sParams;
s30 = pTyp:sUpLimPar;
s31 = pTyp:sLowLimPar;
s32 = '';
s33 = '';
while (c<=sPa) {term.GetVal(D1,'params',c);
s4 = strtok(s3,token,tok_pos,c);
i = strcmp(s4,'');
if (i) {j = strcmp(s32,'');
s33 = sprintf('%s\t%g',s33,D1);
if (.not.j) s32 = sprintf('%s',s4);
else s32 = sprintf('%s\t%s',s32,s4); }
85
c+=1; }
c=0;
z = strcmp(s30,'');
d = strcmp(s31,'');
if (d) {while (c<sPa) {s5 = strtok(s31,token,tok_pos,c);
i = strcmp(s5,'');
if (i) {s33 = sprintf('%s\t%g',s33,D1);
s32 = sprintf('%s\t%s',s32,s5); }
c+=1; }}
c=0;
if (z) {while (c<sPa) {s6 = strtok(s30,token,tok_pos,c);
i = strcmp(s6,'');
if (i) {s33 = sprintf('%s\t%g',s33,D1);
s32 = sprintf('%s\t%s',s32,s6); }
c+=1; }}
fprintf(2,'%s\t%s',term:loc_name,s32);
fprintf(2,'%s\%s',pElm:loc_name,s33);
break;
r+=1; }}
else{i = term.VarExists('tvm');
if (i) {fprintf(2,'VCO_%s\ttvm\tvspp\ttspi\tur_mx\tur_mn\tterr\tvss\ttst\tefdmx\tefdmn\tkur\t
kui\tkir\tkii',pElm:loc_name);
s7 = sprintf('%s\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g',pElm:loc_name,term:tvm,
term:vspp,term:tspi,term:ur_mx,term:ur_mn,term:terr,term:vss,term:tst);
fprintf(2,'%s\t%g\t%g\t%g\t%g\t%g\t%g',s7,term:efdmx,term:efdmn,term:kur,term:kui,ter
m:kir,term:kii); }
else fprintf(2,'Sin Tipo de PSS'); }}
else {fprintf(2,'%s',pElm:loc_name);
fprintf(2,'Sin Estabilizador de Potencia'); }}
cont +=1; } }
else{fprintf(2,'Sin Modelo');
fprintf(2,'%s',pElm:loc_name); }
pElm = Elm.Next();}
pGrd = Grids.Next(); }
fclose(2);
Se termina el script y se empieza el análisis en excel
86
o Ke [p.u.]: Ganancia de excitación (Excitor Gain).
o Te [s]: Constante de tiempo de excitación (Excitor Time Constant).
o Kf [p.u.]: Ganancia de trayectoria de estabilización (Stabilisation Path
Gain)
o Tf1 [s]: Constante de tiempo del primer paso de la trayectoria de
estabilización (Stabilisation Path First Time Const).
o Tf2 [s]: Constante de tiempo del segundo paso de la trayectoria de
estabilización (Stabilisation Path Second Time Const).
o KA [p.u.]: Ganancia del regulador de voltaje (Voltage Controller Gain).
o TA [s]: Constante de tiempo del regulador de voltaje (Voltage Controller
Time Constant).
o Min [p.u.]: Voltaje mínimo de excitación (Excitation Minimum Voltage).
o Max [p.u.]: Voltaje máximo de excitación (Excitation Maximum Voltage).
• Segundo grupo de datos:
o Tr: Tiempo de retardo (Measurement Delay).
o Ke: Ganancia de excitación (Excitor Gain).
o Te: Constante de tiempo de excitación (Excitor Time Constant).
o Ka: Ganancia del regulador de voltaje (Voltage Controller Gain).
o Ta: Constante de tiempo del regulador de voltaje (Voltage Controller
Time Constant).
o Tb
o PSS/E_ScIngFctr
o Vrmin: Voltaje mínimo de excitación (Excitation Minimum Voltage).
o Vrmax: Voltaje máximo de excitación (Excitation Maximum Voltage).
• Tercer grupo de datos:
o Tr: Tiempo de retardo (Measurement Delay).
o Tc1, Tc2
o Tb1, Tb2
o Kr
o Ts
o Upmn, Upnmx
• Cuarto grupo de datos:
o Kd
o Ke: Ganancia de excitación (Excitor Gain).
o Kc
o Tr: Tiempo de retardo (Measurement Delay).
o Ae: Factor proporcional de saturación (Saturation Proportional Factor).
o Be: Factor exponencial de saturación (Saturation Exponential Factor).
o Te: Constante de tiempo de excitación (Excitor Time Constant).
o Kb
o Ka: Ganancia del regulador de voltaje (Voltage Controller Gain).
o Ta: Constante de tiempo del regulador de voltaje (Voltage Controller
Time Constant).
o Vlr_const
o Tc
o Tb
o Kf: Ganancia de trayectoria de estabilización (Stabilisation Path Gain)
87
o Tf
o Kh
o Kl
o Vemin
o Vamin, Vamax
o Vrmin: Voltaje mínimo de excitación (Excitation Minimum Voltage).
o Vrmax: Voltaje máximo de excitación (Excitation Maximum Voltage).
• Quinto grupo de datos:
o prv6
o trv6
o grv1
o Trv1, Trv2
o prv1
o uex_min, uex_max
o Ke: Ganancia de excitación (Excitor Gain).
o Te: Constante de tiempo de excitación (Excitor Time Constant).
o Ae: Factor proporcional de saturación (Saturation Proportional Factor).
o Be: Factor exponencial de saturación (Saturation Exponential Factor).
• Sexto grupo de datos:
o Tb
o Ta: Constante de tiempo del regulador de voltaje (Voltage Controller
Time Constant).
o K
o Te: Constante de tiempo de excitación (Excitor Time Constant).
o Switch
o Emin, Emax
• Séptimo grupo de datos:
o Tr: Tiempo de retardo (Measurement Delay).
o Ka: Ganancia del regulador de voltaje (Voltage Controller Gain).
o Kq
o Te: Constante de tiempo de excitación (Excitor Time Constant).
o Ta: Constante de tiempo del regulador de voltaje (Voltage Controller
Time Constant).
o Upmn, Upmx
• Octavo grupo de datos:
o Vmks, Vmkd, Vmkt
o Kpe
o Kie
o rl_ki
o ql_ki
o qki
o qkp
o qmin_cnst
o iemax_cnst
o Switch
o Vcn
o Vqlmin, Vqlmax
88
o Vrlmin, Vrlmax
o Vmmin, Vmmax
o Vcp
89
o T2: Compressor Delay Time Constant
o MWb
o MVAb
o Kgov
o Db
o Lap
o Pmin, Pmax
o RCHmin, RCHmax
• Tercer grupo de datos:
o Prx
o Pcr
o Drp
o Dbd
o Tvirt1, Tvirt2
o Tisp
o Thp
o Tmd
o Tnd
o alfHp, alfMp
o db
o Tyo
o Tyc
o Ty
o Reserve
o Kp
o Ti: Power Gradient Limiter Time Constant
o Min, Max
o Tr: Rated Exhaust Temperature
o Ytmin, ytmax
o y_min, y_max
• Cuarto grupo de datos:
o Tt [s]: Turbine Time Delay
o v0 [p.u]: Turbine Factor
o bf [p.u]: Turbine Controller Droop
o Ti [s]: Power Gradient Limiter Time Constant
o Tv [s]: Measurement Delay
o T1 [s]: Compressor Derivative Time Constant
o T2 [s]: Compressor Delay Time Constant
o K [p.u]: Compressor Factor
o y_min [p.u]: Gradient Limiter Minimum Value
o GT_min [p.u]: Minimum Torque
o y_max [p.u]: Gradient Limiter Maximum Value
o GT_max [p.u]: Maximum Torque
o Dbd [p.u]: SpCntrl Dead Band
o Pres [p.u]: max. Primary Reserve
• Quinto grupo de datos:
o W [p.u]: Speed Controller Gain
90
o X [s]: Speed Controller Der.Time Const.
o Z [p.u]: Speed Controller Is/Dr (0/1)
o Y [s]: Speed Controller Time Constant
o K3 [p.u]: Turbine Factor
o Ttr [s]: Transport Delay
o a [p.u]: Fuel System Prop. Characteristic
o b [s]: Fuel System Time Constant
o c [p.u]: Fuel System I/L Factor (0/1)
o Tf [s]: Fuel System Delay
o Kf [p.u]: Fuel System Feed Back Factor
o Ecr [s]: Fuel System Delay
o Tcd [s]: Turbine Time Delay
o af2 [p.u]: Turbine Characteristic, Constant
o bf2 [p.u]: Turbine Characteristic, Torque
o cf2 [p.u]: Turbine Characteristic, Speed
o K6 [p.u]: Compressor Factor
o Trate [MW]: Turbine Rated Power
o Kac [p.u]: Acc. Gain
o Tn [s]: Acc. Controller Diff. Constant
o Etd [s]: Temperature Controller Delay
o Tr [grd.C]: Rated Exhaust Temperature
o af1 [grd.C]: Temperature Factor 1 (Torque)
o bf1 [grd.C]: Temperature Factor 2 (Speed)
o Ta [grd.C]: Ambient Temperature
o K4 [p.u]: Radiation Shield Prop. Factor
o K5 [p.u]: Radiation Shield Integr. Factor
o T3 [s]: Radiation Shield Time Constant
o T4 [s]: Thermocouple Time Constant
o Tt [s]: Temperature Controller Time Constant
o T5 [p.u]: Temperature Controller Gain
o Min [p.u]: VCE Lower Limit
o Max [p.u]: VCE Upper Limit
o PRes [p.u]: Primary Reserve
o Dbd [p.u]: Speed Dead Band
• Sexto grupo de datos:
o K: Gain = 100/Drp [-]
o T: SpCntrl Time Constant [s]
o Dbd: SpCntrl Dead Band [p.u]
o y_min, y_max
• Séptimo grupo de datos:
o Tl
o Tw
o Rb
• Octavo grupo de datos:
o Prx
o Pcr
o Drp
91
o Dbd
o Tvirt1, Tvirt2
o Tisp
o Thp
o Tmd
o Tnd
o alfHp, alfMp
o db
o Tyo
o Tyc
o Ty
o Reserve
o Kp
o Ti
o Min, Max
o Tr
o Ytmin, ytmax
o y_min, y_max
92
93