Presentació1 (1).ppt interfaces graficas

1.INTRODUCCIÓN
1.1 ¿En que consiste?
-Se trata de una aplicación en formato de ventanas, que permitirá el análisis de guías de
onda y discontinuidades a partir del cálculo de parámetros característicos.
-Proporciona también una visualización de la estructura bajo análisis y herramientas
de visualización gráfica de sus correspondientes parámetros calculados.
-En esta aplicación, está incluida una aplicación para la transformación de parámetros
S-Y-Z
Figura 1. Ventana principal de I.G.

1.2 Contenido.
I. G. Contiene 4 menús desplegables:
1º SDA (Spectral Domain Approach method) [1]:
- 4 Acciones.
2ºGTR (Generalized Transversal Resonance method) [2]:
-3 Acciones.
3º Aplications:
-2 Acciones.
4º TLM method [3]:
-1 Acción.
Figura 2. I.G. con el submenú “GTR (Generalized Transversal Resonance method)” desplegado.

1.3 Ejemplo.
Figura 3. Ventana de la aplicación “SDA para una guía de ondas coplanar (CPW)”

2.OBJETIVOS
-1º Proporcionar un “software” basado en un sistema de ventanas didáctico para el análisis
de guías de onda y discontinuidades.
-2º Visualización de la estructura bajo análisis.
-3º Adaptar a la aplicación (en lo posible) motores de cálculo de parámetros de guías de onda
implementados en FORTRAN [4] por antiguos proyectistas de la UPC.
-4º Herramientas de visualización para los valores o parámetros calculados
-5º La posibilidad de guardar y recuperar los parámetros calculados tras un proceso de
análisis o simulación.

2º Visualización de la estructura bajo análisis.
Figura 4.. Esquema gráfico de una guía de ondas coplanar (CPW) que nos ofrece la aplicación
“SDA para una guía de ondas coplanar (CPW)”

4º Herramientas de visualización para los valores o parámetros calculados.
Figura 5. Ventana de la aplicación “SDA para una
guía de ondas coplanar (CPW)”.
En la figura 5 podemos ver enmarcados en rojo los
“widgets” encargados de activar y escoger el
formato de las gráficas.
Figura 6. Gráfica de valores de “Beta” en
función de “Frecuencia de estudio” para
una guía coplanar (“CPW”).
En la figura 6 vemos la aplicación amigable
que nos ofrece I.G. para un manejo de
gráficas.

3.HERRAMIENTAS DE TRABAJO
3.1 Introducción.
-Inicialmente, se dispone de unos motores de cálculo implementados en
FORTRAN.
-El diseño debía estar fundamentado en el funcionamiento de estos ejecutables.
-Se debe encontrar un medio para diseñar una plataforma gráfica que pueda
interactuar con estos motores.
-En definitiva, se trata de reciclar estos ejecutables encontrando un medio para
integrarlos o modificarlos con el fin de obtener una interfaz gráfica de usuario más
práctica y versátil.

3.2 Características de los ejecutables:
-Creados a partir de métodos numéricos de análisis de guías de onda:
SDA (Spectral Domain Approach)
GTR (Generalized Transversal Resonance)
TLM (Transversal Line Method)
GSM (Generalized Scattering Matrix)
-Interactúan con el usuario mediante ventanas MS-DOS.
-Precarios esquemas creados a partir de caracteres. (véase figura 7.)
Figura 7. Impresión que vemos por pantalla al ejecutar “sdaflnin.exe”

-Nulo control de excepciones.
-Imprimen los resultados en ficheros “output.dat”:
Formato de impresión de datos en FORTRAN.
Impresión tabulada de los datos en columnas.
3.3 QT y PYTHON.
-Búsqueda de un entorno que permita el diseño de una interfaz gráfica de usuario.
-Se desecha ,por motivos que veremos más adelante, el uso de herramientas de diseño de
plantillas gráficas relacionadas con FORTRAN.
-Búsqueda de una opción más manejable. Requisitos:
1. Plataforma de diseño de elementos gráficos en formato de ventanas de uso y
distribución gratuita.
2.Encontrar un código que permita manejar las interacciones usuario-máquina
de estos elementos gráficos. A ser posible, código más manejable que
FORTRAN.
3. El código seleccionado debe tener herramientas para elaborar gráficas
,a ser posible interactivas con el usuario. Hay que tener la posibilidad de
guardar estas gráficas en un formato reutilizable.

1. Plataforma de diseño de elementos gráficos en formato de ventanas de uso y
distribución gratuita:
QT [5]: Biblioteca multiplataforma para el diseño de interfaces gráficas de usuario, ver
figura 8.
Figura 8. Imagen de la plataforma de diseño de GUI´s QT.

-Características importantes de QT:
-Librería de elementos gráficos totalmente gratuita.
-Creada para el diseño de GUI´s (Grafic User Interfaces) manejadas desde código C y
PYTHON.
- QTDessigner contiene un paquete de elementos gráficos o “widgets” clasificados que se
pueden arrastrar a la plantilla de diseño.
-Plantilla de diseño de clase “QDialog” , “QWidget” o QMainWindow”.
-Property Editor muestra las características del “widget” actual selecionado.
-Podemos editar orden de tabulación y nuestros propios “signals/slots”.
-Guardamos nuestros proyectos en un formato “proyecto.ui”.
2-3. Lenguaje PYTHON [6], libre uso y distribución que maneja el paquete de
elementos visuales de QT y ofrece herramientas para realizar gráficos.
-Características descriptivas y ventajas de PYTHON:
-Para realizar gráficas usa el paquete de elementos gráficos TK [7].
-Lenguaje basado en C++ optimizado, orientado a objetos.
-Aprendizaje rápido e intuitivo.
-Diseñado como proyecto de código abierto.
-Gran colección de módulos estándar que pueden ser utilizados como base de los programas.
-Relación muy documentada con QT.

4.¿POR QUE PYTHON?
4.1 Principales problemas de FORTRAN para el no iniciado.
-No favorece su legibilidad y es un código casi puramente estructurado:
-Longitud de los nombres de las variables (max 8 caracteres).
-No favorece la un código ordenado. (No es preciso un “sangriado” o “identación”
del código).
-Es un código fuertemente “tipado”.
-Sintaxis altamente compleja.
-Dispone de funciones y módulos para el manejo y cálculo con matrices complejas
pero pocas de ellas se encuentran disponibles de manera gratuita.
-Algunos tipos de dato en concreto són exclusivos de algunas plataformas. Por ejemplo:
Complex64 [8].
-La herramienta de diseño de interfaces Visual Fortran, no es gratuita y tiene un modo de
trabajo e integración de la interfaz poco intuitivos.
-Las aplicaciones para realizar gráficas 2D en FORTRAN son escasas y están más orientadas a
pizarra más que a una utilidad científica.

-Ejemplo:
En FORTRAN se tiene lo siguiente:
DibujaLinea (x1,y1,x2,y2)
Esto dibuja una lina que pasa por 4 puntos en FORTRAN como vemos en la
figura 8.
Figura 9: Linea dibujada por Fortran mediante 4 puntos.
No se puede hacer un zoom, no se puede exportar a imagen,
no se puede cambiar la escala, no se desplaza el eje, no tiene leyendas, no tiene
ejes, etc.

En cambio, en PYTHON tenemos esto:
Punto1 = (x1,y1)
Punto2= (x2,y2)
Punto3=(x3,y3)
Punto4=(x4,y4)
MatrizPuntos = [punto1, punto2, punto3, punto4]
Grafica(MatrizPuntos)
Figura 10. Gráfica de beta-frecuencia cuando pulsamos el botón “Mostrar beta-frecuenca
con (d) y (w) constantes” de la aplicación “SDA para una guia de ondas coplanar (CPW).

4.2 Lo que tiene PYTHON que no tiene FORTRAN:
-Tiene un “tipado” dinámico. El tipo de la variable se establece en tiempo de ejecución
cuando le damos un uso.
-Entorno de desarrollo (IDE) práctico (ver figura 11):
-Contiene un intérprete del lenguaje interactivo que favorece su aprendizaje.
-Coloreado selectivo de código.
Figura 11: Imagen del IDE de Python usado para este proyecto: El Python Scripter de MMM-Experts, Inc.

-La longitud de texto de una variable es de 255 caracteres frente a los 8 de FORTRAN.
-En PYTHON todo es un objeto [9].
-PYTHON a diferencia de FORTRAN es multiplataforma “write once rune anywhere” y
no es compilado sino interpretado.
-Si se desea, puede ser compilado, ganando en velocidad de ejecución mediante el módulo
“py2exe”.
-PYTHON es de libre distribución y libre uso.
-PYTHON dispone de una dilatada cantidad de librerías para aplicaciones científicas:
-Numeric [10].
-Numarray [11]: Cálculo con vectores y matrices.
-Numpy [12]: Gran cantidad de constantes universales.
-Linear Algebra [13]: Reúne la mayoría de funcionalidades de la librería IMS
de FORTRAN.
-Matplotlib: Provee de todas las herramientas para el diseño de gráficas
interactivas a partir de TK.
-Tiene una fortísima comunidad en Internet [14]
-Bibliografía para la iniciación en el aprendizaje muy didáctica y de fácil comprensión:
Ej: Dive Into Python [15].

4.3 Relación entre PYTHON y QT: el módulo “pyqt”[16].
-Descubrimiento “pyqt”. Referencias al módulo en Internet.
-”pyqt” proporciona un puente entre QT y PYTHON. Traduce las plantillas de elementos
gráficos creadas con QT a módulos de código manejable en PYTHON.
-”pyqt” dispone de una
extensa bibliografía que
facilita su uso y
aprendizaje.
-Sitio de “pyqt” para su descarga e información:
http://www.riverbankcomputing.co.uk/pyqt/.
-libro de PYTHON y QT: http://www.commandprompt.com/community/pyqt/.
-Proporciona metodología de diseño.
-Concepto “signals/slots”.
-Compatibilización de PYTHON y C++.
-Biblioteca de clases “pyqt”:
http://www.riverbankcomputing.com/Docs/PyQt4/html/classes.html:
-Descripción de la clase.
-Funiones publicas.
-Signals/slots de cada clase
-Descripción en C++
-Subdirectorio de ejemplos de aplicaciones instalado con el módulo “pyqt”:
-Aplicaciones para dibujar.
-Aplicaciones con clase “QtGui.Qdialog” y “QtGui.QMainWindow”.
-Código reutilizable tras un proceso de limpiado.

4.4 Metodología de diseño y formalizaciones.
2º Se crea plantilla de diseño :
“Proyecto.ui”
3º Se extrae formulario en
código PYTHON. Contiene
todos los “widgets” traducidos
a código manejable PYTHON:
“frmProyecto.py”.
1º Seleccionamos tipo de
plantilla de diseño en la
plataforma QT: “QDialog”,
“QMainWindow” o “Qwidget”.
4º Mediante nuestro IDE de
PYTHON, creamos el “script”
“dlgProyecto.py” a partir del cual
manejamos la interacción usuario-
máquina con la interfaz creada.
5º Creamos el ejecutable
externo“Proyecto.py”, maneja la
aplicación para manejar gráficas.
1er paso: Trabajo en QT
Comando en MS-DOS
proporcionado por “pyqt”.
Sentencia “inport”
“frmProyecto.py”.
Llamada al
ejecutable con la
instrucción
“spawnv()”.
2o paso: Trabajo en PYTHON

4.5 Pasar de FORTRAN a PYTHON.
-1ª opción: Traducir código de los ejecutables FORTAN a PYTHON:
-Uso del módulo “F2py”. =
-Pertenece al módulo “Numpy”.
-No es un traductor, permite el uso de funciones FORTRAN
desde PYTHON. Establece un puente.
-Tiene muchas limitaciones.
-2ª opción: Traducir manualmente FORTAN a PYTHON:
-Se dispone de librerías que contienen prácticamente las mismas funciones IMS de
FORTRAN: “LinearAlgebra” y “Numarray”.
-Se dispone de los códigos de los motores FORTRAN.
-Tras un proceso de aprendizage, se tienen los conocimientos para traducir el código
FORTRAN
-Se dispone de la bibliografía de los proyectos que han implementado los motores.
-En apéndices de la bibliografía encontramos ejemplos de código que implementan diversos
motores de cálculo basados en los métodos numéricos bajo estudio [18].
-Este código está escrito en C, realizaremos un ensayo con el código “slabguide”.

4.5.1 Ensayo “dlgSlabguide.py”.
1. Introducción a “dlgSlabguide”.
-Disponemos de las herramientas en PYTHON que suplen el poder de
cálculo en FORTRAN.
-Implementaremos el motor de cálculo a partir del código “slabguide”
que encontramos en la bibliografía [18] sobre el método GTR.
-Realizada a partir de QT y PYTHON. (Procedimiento anterior)
-No está incluido en los ejecutables FORTRAN implementados por
antiguos proyectistas.
2. Objetivo del ensayo.
-Prescindir de los motores FORTRAN disponibles con la intención de
evitar derivaciones en el bucle principal de la aplicación.
-”Testear” la velocidad de procesado de PYTHON para operaciones de
cálculo con matrices complejas.
-Elaborar un boceto de diseño que nos ofrecerá las premisas
principales de nuestra aplicación I.G.

3.Descripción de la aplicación “dlgSlabguide.py”.
-2º Cálculo de
parámetros de una guía
de ondas rectangular
llena por “n” capas de
material dieléctrico.
-Calcula frecuencia de corte de la guía
-Para un barrido de frecuencias entre una frec. Max. y
frec. min con un intervalo de incfrec, calcula:
-La permitividad efectiva (EPSEFF)
-La constante de propagación “Beta”.
-La constante Beta0/Beta ratio.
-3º Proporciona una imagen de la guía bajo análisis proporcional a la realidad
-4º Incluye las primeras herramientas para realizar gráficos.
-1º Se trata de una aplicación en formato de ventana Windows, que proporciona un
diálogo entre el usuario y la máquina.

Introducimos parámetros de la guía Dibuja una guía de ondas rectangular
proporcional a los parámetros
introducidos
Una vez introducidos los parámetros
disponemos de “widgets” para el
cálculo y “graficado” de los
parámetros característicos.
Disponemos de
una tabla dinámica
para la
visualización de
parámetros
calculados
Figura 12: Interfaz de diálogo “dlgSlabGuide.py”.

4º Conclusiones y perspectivas del ensayo “dlgslabguide”.
-Se ha establecido un primer contacto con la interfaz de diseño QT y PYTHON con
resultados satisfactorios.
-En este tanteo se ha registrado la práctica totalidad de los “widgets” necesarios en el
diseño consiguiente. Tenemos:
Botones puslables.
Cuadros de texto.
Esquemas gráficos.
Cuadros de combinación .
Tablas dinámicas para la muestra e introducción de datos.
Una interfaz amigable para mostrar gráficas.
Etiquetas de identificación para objetos.
-Hemos aprendido a usar e importar (instrucción import, inport * from *) el código
autogenerado “frmProyecto.py” y manejarlo desde un script externo “dlgProyecto.py”.

-Se ha profundizado sobre el uso de los métodos y librerías esenciales del módulo “pyqt”:
La librería “QtGui”: Contiene el cuerpo de todos los
“widgets” que provee “pyqt”.
La librería “QtCore”: Contiene los elementos de interacción con los
“widgets”.
-Conocimiento del método “QObject.connect(“Pyobject”, “PY-Signal()”,self.”función”)”
Concepto de “signals/slots” [19]
Permite conectar los eventos producidos por los “widgets” durante su manejo a
funciones implementadas por el programador .
-Hemos comprobado que la velocidad de cálculo del código PYTHON es sensiblemente más
lenta al FORTRAN.
Se debe considerar que hemos trabajado en la versión interpretada de
PYTHON y no en su versión compilada.
A partir de este momento, usaremos los ejecutables FORTRAN como motores
de cálculo de la interfaz.
Sintetizar los motores de manera que lean los parámetros de cálculo desde un
archivo de “input.dat” (creado por la aplicación) e impriman resultados en un
archivo de “output.dat”.
Importante

5. ESTRUCTURA DE LAAPLICACIÓN
5.1 Diagrama de bloques de I.G.
Ventana Principal:
“Waveguides.py”
1.Primer submenú:
SDA (“Spectral Domain Approach method”)
2. Segundo submenú:
GTR (“Generalized Transverse Resonance method”)
3. Tercer submenú:
Aplications
4. Cuarto submenú:
TLM method
Figura 13: organigrama de los submenús de la ventana principal de I.G.

1er submenú: SDA (“Spectral Domain Approach method”)
1. Primer submenú:
SDA (Spectral Domain Approach method)
1.1. Primera acción:
SDA para una CPW (Coplanar Waveguide)
1.2. Segunda acción:
SDA para una finline
1.3. Tercera acción:
SDA para una strip-line
1.4. Cuarta acción:
SDA para una finline no simétrica
Figura 14: Organigrama de funciones del submenú desplegable “SDA (Spectral Domain Approach method)”

2º Submenú: GTR (“Generalized Transversal Resonance method”)
2. Segundó submenú:
GTR (Generalized Transverse Resonance method)
GTR para una finline
GTR para un resonador
2.3. Tercera acción:
GTR. Coeficiente de reflexion y reactancia eq. De una finline
Figura 15. Organigrama de funciones del submenú desplegable GTR (“Generalized Transverse
Resonance method”)

3er submenú: Aplications
3. Tercer submenú:
Aplications
SYZ Transformador de parametros S-Y-Z
Longitud de resonancia a partir de parametros S
Figura 16. Organigrama de funciones del submenú desplegable “Aplications”.

4º submenú: TLM (“Transversal Line Method”).
4. Cuarto submenú:
TLM (“Transversal Line method”)
TLM
Figura 17 Organigrama de funciones del submenú desplegabes “TLM (“Transversal Line method”)

Modo de funcionamiento interno esquematizado.
Activamos la aplicación.
Ejecutamos remotamente un
“dlgAplicación.py”
Introducimos parámetros y
Pulsamos el botón “Calcular”.
Generamos un “fichero.dat” de con los datos de
la guía.
Se importan las librerias
Desde el directorio “formularios”,
Importamos e inicializamos los objetos
del formulario
“frmAplicación.py”
Usamos los “widjets”
para visualidar los
resultados calculados
“Lanzamos” una llamada
al ejecutable Fortran de “ouput”,calula parámetros a partir
de los datos que extrae del “fichero.dat”
Visualizamos los
resultados
Leemos los datos de “ouput” del
Ejecutable FORTRAN y los guardamos en
un “archivo.dat” del subdirectorio
“graficas”
“Lanzamos” el ejecutable
para “plotear” los resultados:
“Aplicación.py”
Ventana principal de la aplicación I.G.
Figura 19: Esquema de funcinamiento general de las aplicaciones.
Notas: Este diagrama
se puede extrapolar a
todas las
aplicaciones de I.G.
Para tener una visión
mas amplia repasar
diapositiva nº 18

5.2 Descripción de las aplicaciones.
5.2.1 Recorrido completo por “SDA para una CPW (Coplanar Waveguide)”:
el ejecutable “dlgSDAbilateral.py”.
FIgura 18: Ventana de la aplicación “SDA para una guía de ondas coplanar (CPW)”

Introducción
-Consiste en 3 pasos:
1. Se introducen dimensiones y constantes características de la guía.
2. Se introduce un rango de frecuencias y un valor de incremento de
esta para realizar un barrido de cálculo.
3. Se calculan parámetros “Beta” y Z0” y se muestran gráficas de los
valores calculados.
-Muestra una imagen proporcional a la realidad y interactiva en 3 dimensiones de una guía
de ondas coplanar (CPW).
-Realiza los cálculos para un barrido del ancho de “slot” (w), la distancia entre
“slots”(d) y un rango de frecuencias.
-Simula el funcionamiento del ejecutable de “input” “sdacpwin.exe”.
-Se puede deducir el funcionamiento de los núcleos FORTRAN a partir del funcionamiento
de la aplicación:
Establecen las premisas y reglas de diseño.

Ejecutable “sdacpwin.exe”
-Características:
-Crea un “fichero_entrada.dat” con las dimensiones y constantes carácterísticas
de una guía de ondas coplanar.
-Muestra a través de una ventana MS-DOS, una precaria imagen de una guía
de ondas CPW.
Figura 20. Impresión que vemos por pantalla al ejecutar “sdacpwin.exe”
-Se adaptará prácticamente la misma nomenclatura para definir los parámetros de entrada
en la interfaz gráfica.

Ejecutable “sdacpwe.exe”:
-Características:
-Lee desde “fichero_entrada.dat” las características de la guía.
-Calcula el modo par de una guía de ondas coplanar (CPW).
-Crea un “fichero_salida.dat” (“sdacpwe.dat”) con la parte real e imaginaria de
“Beta” y Z0” calculados para un barrido de valores de “w” y “s”.
Ejecutable “sdacpwo.exe”:
-Características:
-Ídem de las anteriores, a excepción que calcula el modo impar de una CPW e
imprime los resultados en “sdacpwo.dat”.
Formato de impresión de los arhivos:
Figura 21. Archivo de datos “sdacpwo.dat”

1er paso: Introducimos las dimensiones y constantes de la guía CPW.
Figura 22. 1er paso de la aplicación “SDA
para una guía de ondas coplanar (CPW)” :
“Group box” con el título “Introduzca datos
de la guía”.
Figura 23. Esquema gráfico de una guía de
ondas coplanar (CPW) que nos ofrece la
aplicación “SDA para una guía de ondas
coplanar (CPW)”.
Mediante este “combobox” o cuadro de
combinaciones, se selecciona el motor de
cálculo “sdacpwe.py” o “sdacpwo.py”.
El esquema gráfico se modifica
proporcionalmente a medida que
introducimos valores.

1er paso: Observaciones y características:
-Se usa la misma nomenclatura para denominar las variables que usa “sdacpwin.exe”.
-Cuadros de texto unidos a una regla de validación: no se pueden introducir
valores incloerentes.
-Se piden y almacenan todos los valores requeridos por “sdacpwo.exe” y
“sdacpwe.exe”.
2º paso: Introducimos las dimensiones y constantes de la guía CPW.
Figura 24. Cuadro de grupo
“Introduzca rango de
frecuencias de estudio” de la
aplicación “SDA para una guia
de ondas coplanar (CPW)”.
Mediante estos “textbox” o cuadro de
texto, se introduce el valor mínimo y
máximo del rango de frecuencias de
estudio
En “textbox” se introduce de incremento
de valores dentro del rango de frecuencias
Observaciones y características:
-No están sujetos a la misma regla de validación que los cuadros de texto del 1er paso.
-Parámetros no requeridos por los motores FORTRAN.
-Se introduce una nueva dimensión de cálculo disponible.

3er paso: Se calcula y se muestran los valores calculados en gráficas interactivas.
Figura 25. Cuadro de grupo “Cálculo y gráficas de
parámetros” de la aplicación “SDA para una guía de ondas
coplanar (CPW)” antes de iniciar el cálculo
Figura 26A. Cuadro de grupo “Cálculo y gráficas de
coplanar (CPW)” después de terminar proceso de cálculo.
-Como se puede obsevar, antes de iniciar el
cálculo tenemos la barra de progreso al 0%,
una vez realizado el cálculo, se habilitarán los
“widgets para graficar y se deshabilitará el
botón de cálulo.

Observaciones y características del 3er paso (parte A):
Figura 26B. Cuadro de grupo “Cálculo y gráficas de
coplanar (CPW)” después de terminar proceso de cálculo.
-Pulsando el botón “Calcular”, “lanzamos” el
ejecutable “sdacpwe.exe” o “sdacpwo.exe”.
Durante una iteración del rango de
frecuencias introducido en el 2º paso
-Se ofrecen opciones de barrido posibles:
Para frecuencia (f).
Para el ancho de slots (w).
Para la distancia entre slots (d).
-Se tiene la posibilidad de contemplar una
tabla de resultados calculados o su gráfica.
-Se tiene la opción de mostrar la parte REAL,
IMAGINARIA o ambas de los parámetros
calculados.

Observaciones y características del 3er paso (parte B):
Figura 27. Gráfica de beta-frecuencia cuando pulsamos
el botón “Mostrar beta-frecuenca con (d) y (w)
constantes” de la aplicación “SDA para una guia de
ondas coplanar (CPW) y seleccionamos la opción
“Tabla resultados”.
-Los botones para mostrar gráficas “lanzan” el ejecutable externo. “SDAbilateral.py”:
Aplicación externa al hilo de ejecución de “SDAbilateral.py”.
“SDAbilateral.py” maneja funciones y módulos de la librería de elementos gráficos TK.
Se pueden visualizar simultáneamente tantas gráficas como se desee.
Se proporciona una interfaz amigable para el
manejo de gráficas:
-Podemos guardarlas en un
“formato.png” (por defecto), etc.
-Se puede desplazar gráficas.
-Existe una herramienta para
modificar a placer parámetros
dimensionales de la gráfica.

4º Utilidades y elementos prácticos para la gestión de la aplicación. (Pag 1.)
Cada una de las aplicaciones, se incluye una barra de tareas que nos permitirá, guardar y
cargar simulaciones ya realizadas.
Figura 28: Barra de
herramientas de la
aplicación “SDA para una
guía de ondas coplanar
(CPW)”
Figura 29. Diálogo para guardar simulación de
la aplicación “SDA para una guía de ondas
coplanar (CPW)”.
Figura 30. Diálogo para cargar simulaciones de
la aplicación “SDA para una guía de ondas
coplanar (CPW)”.
“Setea” todos los
“widgets” de la
aplicación y
restablece sus
valores
originales.

4º Utilidades y elementos prácticos que gestionan la aplicación. (Pag 2.)
-Cada una de las aplicaciones añadirá una firma particular a sus simulaciones:
Es un prefijo de cuatro caracteres que indica el método numérico usado para el
cálculo de los valores almacenados.
Se localizarán en el directorio “muestreos” en un formato “.txt”.
-Las aplicaciones proporcionan un sistema de control de excepciones y errores.
Evita incoherencias en los parámetros de entrada.
Usa pequeños diálogos modales “prefabricados” a modo de señalización y
orientación del usuario durante la introducción de parámetros de entrada.
Figura 31, ventana de advertencia de la
aplicación “SDA para una guia de ondas
coplanar (CPW)” cuando intentamos cargar un
fichero que no pertenece a la aplicación.
Figura 32. Ventana de infomación que se muestra cuando
pulasmos el boton “Calcular constante de propagacion (β)
i Z0” y no hemos introducido todos los parámetros
correctamente de la apliación “SDA para una guía de
ondas coplanar (CPW)”

5.2.2 “SDA para una guía de ondas finline”: el ejecutable “dlgSDAsim.py.
Resumen de la aplicación.
FIgura 33: Imagen de la aplicación “SDA para una guía de ondas finline”

Descripción abreviada “dlgSDAsim.py”.
-Obtiene los parámetros calculados de “Beta” y Z0” de una guía de ondas “finline” a partir
del motor FORTRAN “sdafln.exe” basado en el método numétrico SDA.
de ondas “finline” con 3 capas de material semiconductor.
-Realiza los cálculos para un barrido del ancho de “slot” (w) y un rango de frecuencias.
-Simula el funcionamiento del ejecutable de “input” “sdaflnin.exe”.
-Se puede deducir el funcionamiento del núcleo FORTRAN a partir del funcionamiento
de la aplicación:
-Funciona del mismo modo que la aplicación. “SDA para una CPW (“Coplanar
Waveguide”)”.
-Usa el ejecutable externo “SDAsim.py”, para crear la interfaz que crea y permite
manejar las gráficas.

5.2.3 “SDA para una “strip-line”: el ejecutable “dlgSDAstrip.py”.
FIgura 34: Imagen de la aplicación “SDA para una “strip-line””

Descripción abreviada “dlgSDAstrip.py”.
-Obtiene los parámetros calculados de “Beta” y Z0” de una guía de ondas rectangular con
un “strip” centrado a partir del motor FORTRAN “sdastrip.exe” basado en el método
numérico SDA.
de ondas rectangular con un “strip” centrado con 3 capas de material semiconductor.
-Realiza los cálculos para un barrido del ancho de “strip” (w) y un rango de frecuencias.
-Simula el funcionamiento del ejecutable de “input” “sdastrin.exe”.
de la aplicación:
Waveguide”)”.
-Usa el ejecutable externo “SDAstrip.py”, para crear la interfaz que crea y permite

5.2.3 “SDA para una “finline” asimétrica”: el ejecutable “dlgSDAunidesp.py”.
FIgura 35: Imagen de la aplicación “SDA para una “finline” asimétrica”

Descripción abreviada “dlgSDAunidesp.py”.
-Obtiene los parámetros calculados de “Beta” y Z0” de una guía de ondas rectangular con
un “slot” asimétrico a partir del motor FORTRAN “sdaflnd.exe” basado en el método
numérico SDA.
de ondas “finline” asimétrica con 3 capas de material semiconductor.
-Realiza los cálculos para un barrido del ancho de “slot” (w), el desplazamiento del “slot”
desde la pared lateral de la guía (d) y un rango de frecuencias.
-Simula el funcionamiento del ejecutable de “input” “sdaflndin.exe”.
de la aplicación:
Waveguide”)”.
-Usa el ejecutable externo “SDAunidesp.py”, para crear la interfaz que crea y permite

5.2.4 “GTR para una “finline””: el ejecutable “dlgGTRslotline.py”.
FIgura 36: Imagen de la aplicación “GTR para una “finline””

Descripción abreviada “dlgGTRslotline.py” (A).
-Obtiene la parte real de los parámetros calculados de “Beta” y la constante dieléctrica
efectiva “Ereff” de una guía de ondas rectangular con un “slot” asimétrico a partir del
motor FORTRAN “gtrfin.exe” basado en el método numérico GTR.
de ondas “finline” asimétrica con una capa de material semiconductor.
Nota. Cada capa de material dieléctrico introducida en la guía, produce un
incremento exponencial de las matríces de cálculo en el método GTR.
-Realiza los cálculos para un barrido de:
-Altura de la guía (BT).
-Ancho de la guía (AT).
-Constante dieléctrica relativa de la capa semiconductora. (EPSR)
-Ancho del “slot” (W).
-Desplazamiento lateral del “slot” respecto a la cara metálica inferior (B1).
-Ancho de la capa dieléctrica (S).
-Desplazamiento lateral de la capa respecto a la cara metálica lateral (A1).
-Número de modos al “slot” (Modslot).
-Número de modos en la guía (Modguia).

Descripción abreviada “dlgGTRslotline.py” (B).
-Simula el funcionamiento del ejecutable de “input” “gtrfinin.exe”.
de la aplicación:
Waveguide”)”.
-Usa el ejecutable externo “GTRslotline.py”, para crear la interfaz que crea y permite

5.2.5 “GTR para un resonador”: el ejecutable “dlgGTRresonador.py”.
FIgura 37: Imagen de la aplicación “GTR para un resonador”

Descripción abreviada “dlgGTRresonador.py” (A).
-Obtiene la longitud e resonancia (“Lx”) de una guía de ondas rectangular con un “slot”
asimétrico y un resonador a partir del motor FORTRAN “gtrfines.exe” basado en el
método numérico GTR.
de ondas “finline” asimétrica con una capa de material semiconductor.
Nota. Cada capa de material dieléctrico introducida en la guía, produce un
incremento exponencial de las matríces de cálculo en el método GTR.
-Realiza los cálculos para un barrido de:
-Altura de la guía (BT).
-Ancho de la guía (AT).
-Constante dieléctrica relativa de la capa semiconductora. (EPSR)
-Ancho del “slot” (W).
-Desplazamiento lateral del “slot” respecto a la cara metálica inferior (B1).
-Ancho de la capa dieléctrica (S).
-Desplazamiento lateral de la capa respecto a la cara metálica lateral (A1).
-Número de modos al “slot” (Modslot).
-Número de modos en la guía (Modguia).
-Distancia entre el “slot” y el resonador (BS)
-Ancho del resonador (WS)
-Distancia del resonador a la pared “cortocicuito” de la guía (L2)
-Longitud del resonador (LS).

Descripción abreviada “dlgGTRslotline.py” (B).
-Simula el funcionamiento del ejecutable de “input” “gtrfiresin.exe”.
de la aplicación:
Waveguide”)”.
-Usa el ejecutable externo “GTRfinres.py”, para crear la interfaz que crea y permite

5.2.6 “Herramienta de transformación SYZ”: el ejecutable “dlgSYZ.py”.
FIgura 38: Imágen de la aplicación “ Herramienta de transformación S-Y-Z.” (1ª pagina).

Descripción abreviada “dlgSYZ.py”.
-Se trata de una herramienta para convertir datos en parámetros S (“scattering”), Z
(impedancia), y Y (admitancia) de un modo “multidireccional”, es decir, de cualquier de
estos tres tipos de parámetros a otro de los mencionados.
de la aplicación:
-Usa el mismo protocolo de funcionamiento respecto a los motores de cálculo FORTRAN de
las otras aplicaciones:
-Imita de mediante una interfaz de usuario el funcionamiento de un ejecutable
de “input” (“SYZin.exe”) que crea un archivo de datos que tomara el
ejecutable de “output”.
-Usa un motor de cálculo implementado en FORTRAN (“SYZ.exe”), que
imprimirá los resultados en un archivo y que serán capturados y mostrados por
la aplicación.
-Se convertirán la parte real e imaginaria de una matriz de cuatro parámetros a otra matriz
con el mismo número de parámetros.

3er paso.
-Crea el fichero “SYZin.dat” con el nombre del archivo con los datos de entrada, el nombre
de archivo con los datos de salida y la dirección de conversión: S(Y), S(Z), Z(S), Z(Y), Y(S),
Y(Z).
-Lanza el motor “SYZ.dat”, extrae los valores calculados del fichero “SYZ.dat”
-Imprime los resultados en la segunda página de la aplicación.
1er paso.
-Se selecciona si se introducen núevos parámetros S, y o Z, o
por otro lado si se extraerán desde un fichero existente.
-En caso afirmativo se habilitarán los 4 cuadros de texto que
contienen los parámetros de entrada (parte real e imaginaria).
Nota: el funcionamiento es ligeramente
diferente que el de casos anteriores, el motor de
cálculo FORTRAN SYZ.exe extrae información
de 2 ficheros de entrada, uno contiene los
nombres de los ficheros de entrada y salida y el
tipo de conversión, el otro contiene los
parámetros a convertir.
2º paso.
-Se selecciona un archivo que contiene los
parámetros de conversión. (en caso de haber
seleccionado la opción)
-Se introduce el nombre del fichero con los
parámetros convertidos. (No más de 8 caracteres).
-Se elige la dirección de transformación.
Ir transparencia
siguiente.

4º paso: Visualizamos los valores calculados
FIgura 39: Imágen de la aplicación “ Herramienta de transformación S-Y-Z.” (2ºª pagina).

5.2.7 “Longitud de resonancia a partir de parámetros S”:
-Se trata de una aplicación que determina la longitud de resonancia de una
estructura a partir de los parámetros S obtenidos a partir de un analizador
de redes.
-El motor FORTRAN de esta aplicación recibe el nombre de “lfroms.exe”.
5.2.8 “Transversal Line Matrix method 3D, link”:
-Se establece un link a una aplicación que analiza diferentes
estructuras a partir del método numérico TLM.
-Creado por otro proyectista.
Figura 40: Diálogo de información. Aparece cuando se accede a una aplicación no
implementada

6. SINTAXIS DE LAAPLICACIÓN
6.1 Diagrama de bloques de código principales usados en el transcurso de la
aplicación “GTR para una “finline””.
Ventana principal de I.G:
Waveguides methods and aplications
Submenú:
GTR (Generalized Transverse Resonance method)
Acción:
GTR para una finline.
“dlgGTRslotline.py”
Ejecutable de “ploting”
“GTRfinline.py”
Figura 41: Diagrama de bloques de código en el transcurso de la aplicación “GTR para
una “finline””.

6.2 Estructura de código de la ventana principal.
Código ventana principal: “Waveguides.py”. Sobrescribimos en código autogenerado.
1. Se importan bloques y librerías y declaramos variables globales.
import “dirección_módulo”.“nombre_módulo”
from “dirección_módulo”.“nombre_módulo” import “nom_librería”
2. Se crean clases de apoyo.
class “nom_clase”(“tipo_clase”):
3. Se sobrescriben y se crean funciones de la clase principal autogenerada.
-Se crean “widgets” de manera gerárquica.
-Se conectan “widgets” mediante “signals” a funciones implementadas
por el programador.
-Se implementan funciones para manejar “widgets”.
4. Se implementa el código que permitirá que “Waveguides.py” sea ejecutable desde
icono.

Importamos módulos y librerías.
import os, string, sys.
from pyqt import QtCore, QtGui.
from “nom_directorio_diálogos” import “nombre_diálogo”
-Declaramos variables globales: global “nombre_variable”
1
-Herramientas de gestión de eventos.
-Elementos gráficos.
-Con esta instrucción importamos como
módulos la clase principal de nuestros
diálogos, es decir, de las aplicaciones.
Funciones del sistema operativo.
-Contiene variables y métodos para interactuar
con el entorno de la rutina PYTHON:
sys.exit(), sys.argv.
-Proporciona acceso a todas las funciones
propias del sistema operativo: os.spawnv(), etc.
-Proporciona las funciones de manejo de cadenas
de caracteres.

class RenderArea (QtGui.Qwidget):
global “nombre_variable”
def _init_ (self):
QtGui.Qwidget._init_(self, parent):
def paintEvent (self, event):
-objetos de dibujo:
QtGui.Qpainter()
-Formas de dibujo: QtGui.Qrect(),
QtGui.QPainterPath(), QtGui.QTextPath(), etc.
-Propiedades y estilos de formas de dibujo:
QtGui.QPen(), QtGui.Qbrush(), etc.
-Metodos para “setear” propiedades y pintar
formas: .setBrush(“brush”),
.drawPath(“forma”),etc.
-Metodo inicializador general
de clases.
-Hace las veces de
constructor.
-Se llamará a este método
cuando se produzca una
instancia.
-Dentro del método general,
llamamos al método
constructor de clase.
-Dentro de la clase podemos
añadir todos los “widgets”
que se deseen.
Figura 42: Plantilla “Waveguide.ui”, el marco es la superfície de dibujo
2
2º Creamos clase de apoyo: Clase encargada de pintar formas en la superficie de dibujo
, en este cáso, los títulos de cada aplicación.

3º (A) Sobrescribimos las funciones de la clase principal de “Waveguides.py”.
class “nombre_clase_principal” (QtGui.QMainWindow):
método inicializador y constructor de clases (nivel superior a _init_)
def Setupui (self , “nombre_ojeto”):
1º Construimos y inicializamosde manera gerárquica los “widgets que contiene el
“nombre_objeto”:
Barra de herramientas =(QtGui.QMenuBar(“nombre_objeto”))
menús barra de herramientas. (QtGui.QMenu(“nombre_barra_de_herraminetas”))
acciones barra de herramientas. (self.”nombre_menú”.addAction(“Acción”))
Superfície de dibujo: self.gridlayout = QtGui.QWidget(“nombre_objeto”)
2º Conectamos las acciones a las funciones que activan las aplicaciones.
self.connect(“nombre_acción”, “señal_emitida_por_la_acción_al_pulsarse”, “función”)
3º Se llama a la función que escribe etiquetas en los “widgets”.
self.retranslateUi (self, “nombre_objeto”)
método que devuelve las cadenas de caracteres “string()” en formato traducido legible por la máquina..
def tr(self, string):
método que escribe etiquetas en cada widget.
def retranslateUi (self, “nombre_objeto”):

3º (B) Implementamos funciones para activar las aplicaciones y editar la superficie de dibujo.
Creamos las funciones que activarán las aplicaciones:
def “nombre_aplicación”+”f”(self):
En el caso de clases “QtGui.QDialog()”:
d = “nombre_dialogo_aplicación”()
d._exec().
En el caso de clases “QtGui.QMainWIndow()”:
d = “nombre_ventana_aplicación”()
d.show().
d._exec()
Creamos la función que añadirá un dibujo en la superficie de dibujo:
def grafico (self):
self.gridlayout.addwidget(“Clase_Renderarea”)
Pertenece a la clase “nombre_clase_principal”
def setupUi (self, “nombre-objeto”):
método self.connect()

4º (B) Implementamos el código que permitirá que ejecutemos “Waveguides.py” desde icono.
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
WaveGuidesmethods = QtGui.QMainWindow()
ui = Ui_WaveGuidesmethods()
ui.setupUi(WaveGuidesmethods)
WaveGuidesmethods.show()
sys.exit(app.exec_())
El método __name__ siempre vale
“__main__” si no se llama desde
una clase en particular.
Creamos una variable,
contiene el evento principal
del bucle.
Se llama al método
constructor, añadirá todos
los objetos de “nombre_clase
principal” a un objeto del
tipo
“QtGui.QMainWindow”.
Se muestra por pantalla y se
ejecuta la aplicación
principal hasta que esta sea
cerrada.

6.3 Estructura de código de la aplicación “GTR para una finline”.
1. Se importan los módulos y librerías necesarios: Importamos módulo “frmGTRslotline.py”.
2.Declaración de clases de apoyo:
2.1 La clases que manejan las superfícies de dibujo.
2.2 Las clases “validate”: controla la entrada de datos de los cuadros de texto.
3.Declaramos la clase principal.
3.1 Se inicializa la clase y sus “widgtets”
-Se extraen y inicializan los “widgets” de nuestro código autoenenerado.
-Se conectan los “widgets” a los eventos de usuario.
-Se crean y conectan los elementos de la barra de tareas para la gestión de la apliación.
3.2 Se crea la función encargada de manejar nuestro dibujo.
3.3 Se crea la función que creara el fichero de entrada para nuestro motor FORTRAN.
y extraerá los datos del fichero de salida.
3.4 Se crea la función para guardar los datos de la simulación actual.
3.5 Se crea la función para cargar los datos de una simulación realizada.
3.6 Se crea la función para realizar una nueva simulación.
3.7 Se crean las funciones encargadas de “lanzar” el ejecutable que crea las gráficas y preparan el
entorno favorable.
3.8 Se crean las funciones de control particular para cada “widget” durante la entrada de datos.
3.9 Se crea una función de apoyo para advertir al usuario de un posible “excepción”
en los datos que ha introducido.

1.1 Se importan los módulos y librerías necesarios:
import “nombres_librerías_necesarias”.
import Numeric, Numpy, Numarray
from “dirección.directorio_frmGTRslotline” import “GTRslotline”
1.2Declaramos las variables globales al evento.
-Se declaran las variables respectivas a todos los parámetros
de entrada de la aplicación
referentes a las dimensiones de la guía..
Serán comunes a todas las clases:
global “nombre_variable”= “valor”.
-Se declara una variable que validará el proceso de cálculo.
global correcto =False
-Proveen de herramientas
para el manejos de
operaciones con matrices
complejas.
-Cualquier “scrip” en Python
puede ser manejado como un
módulo.
-Importamos la clase principal
del módulo autogenerado que
contiene todos los “widgets” de
nuestra aplicación.
-Contiene el método
“objeto”.setupUi() que
construye y inicializa todos los
“widgets” del módulo.

2.1 Las clases que manejas las superfícies de dibujo.
-En este caso, tenemos cuatro superficies de dibujo,
facilita la tarea de dibujo.
class RenderArea1(QtGui.QWidget):
Se crean variables globales a la clase que almacenan las dimensiones de la guía.
-Se sobrescribe el método inicializador genérico y de clases (“tipo_clase”._init_():)
-Se sobrescribe el método “pintor” (def paintEvent():)
-Se limpia o “resetea” la superficie de dibujo mediante un rectángulo
del mismo color de paleta (se evita dibujos superpuestos)
-Se crea la imagen del interior de la estructura conductora mediante
polígonos a partir de las variables globales a la clase.
-Se crean las acotaciones y etiquetas explicativas.
class RenderArea2 (QtGui.QWidget):
-Ídem, se crea y se acota la parte superior de la guía.
class RenderArea3 (QtGui.Qwidget):
-Ídem, se crea y se acota la cara lateral derecha de la guía.
class RenderAres4 (QtGui.Qwidget):
-Ídem, se acota el ancho de la guía.
Nota: Crear 4 clases para
manejar 4 superficies de
diseño minimiza el esfuerzo
de visión tridimensional para
implementar la imagen de la
estructura conductora, por lo
tanto, se reduce el número de
errores a corregir.
Figura 42. Imagen de las cuatro superficies de diseño tomada de la plantilla gráfica “GTRslotline.ui”.

2.2 La clase “validate”: controla la entrada de datos de los cuadros de texto.
class “nombre_clase”( QtGui.QValidator ):
-Sobreescribimos los métodos inerentes a la clase para
que funcionen según nuestros designios:
1-El método que valida los valores de entrada.
def validate (self, input, posn):
try:
Manejamos la entrada mediante tres estados:
if (input==“valor_deseado”):
return (QtGui.QValidator.Acceptable,posn)
if "None".find(str(input)) == 0:
return (QtGui.QValidator.Intermediate,posn)
if (input==“valor_incorrecto”):
return (QtGui.QValidator.Invalid, posn)
except:
return (QtGui.QValidator.Invalid, posn)
2-El método que inserta en la posición del cursor requerida un valor en caso de retornar
el estado QtGui.QValidator.Invalid
def fixup (self, input):
“valor de retorno”
input.insert(0,”valor_deseado”)
-Está asociada a editores de texto.
-Permite manejar la entrada desde el
teclado sobre el “widget” al que va
asociado.
-Contiene el contenido del cuadro de
texto donde está situado el cursor
cuando se introduce un valor.
-Contiene la última posición del
cursor.
-Estas sentencias
establecen un control de
excepciones.
-No es corriente en esta
clase, se hacen necesarias
debido a que asociadas a
“widgets” construidos en
una clase
“QtGui.QMainWindow”
provoca una excepción
des sistema y salta
Esta sentencia
identifica si el
cuadro de texto se
encuentra en estado
de reposo.

3.1 Se inicializa la clase y sus “widgtets”.
class “nombre_del_diálogo” (QtGui.MainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
-Creamos un objeto que contiene la clase
principal del formulario “frmGTRslotline.py”
self.ui = GTRslotline()
self.ui.setupUi(self)
-Se habilitan las reglas de validación de los cuadros de texto.
-Se inicializa el de los objetos de la aplicación.
-Se establecen parámetros de configuración de la “paleta”.
self.originalPalette = QtGui.QApplication.palette()
self.originalPalette.set(”color_de_la_paleta”)
QtGui.QAplication.set(“estilo_plástico”)
-Se “llama” a la función que crea la imagen de la estructura en simulación.
-Se establecen conexiones los “widgets” a sus funciones respectivas
self.connect(self.ui.”nombre_de_objeto”, “señal_emitida”, self.“función_respectiva”())
-Se crea la barra de herramientas.
Se llama al método “inicializador” de la clase
principal y seguidamente declaramos los
“widgets” que contendrá.
-Se crea un objeto que contiene todos los “widgets”
creados en la plantilla “GTRslotline.py” de la clase
GTRslotline().
-Se ejecuta el método que construye he inicializa los
objetos contenidos en el código autogenerado.
-Siempre, en el interior del método inicializador de
clases genérico.
Nota: Se ha modificado el tipo de la clase principal,
debido a que contiene atributos más interesantes que la
clase QtGui.QDialog.

3.2 Se crea la función encargada de manejar nuestro dibujo.
def graficoexplicativo (self):
-Se debe declarar las variables globales
referentes a las dimensiones de la guía para poder ser usadas
en el método.
global “nombre_variable_de_dimension”
-Se crean 4 variables con cada una de las 4 clases para
dibujar la guía entre las 4 superfícies de diseño.
RenderArea1 = RenderArea1()
-Se actualizan los valores de las dimensiones de la guía.
RenderArea_”num”.”nombre_dimension” = “variable_global_nombre_dimensión”.
Añadimos los objetos pintados a las superficies de dibujo
self.ui.gridlayout_”num” .addwidget(RenderArea_”num”)
-Añade un objeto del tipo “widjet” en
la superficie de dibujo (contenedor de
“widgets”).
-El método, es exclusivo de la clase
QtGui.Qwidget.
-Activa directamente el método
“painter()” de las clases
“RenderArea”.

3.3 Se crea la función que creara el fichero de entrada para nuestro motor FORTRAN.
y extraerá los datos del fichero de salida
def calculaPropagacion (self):
-Importa las variables globales necesarias para la configuración del formato de
datos escritos en el archivo de “input”, imitando al ejecutable de entrada “gtrfinin.dat”.
-Se llama a la función que comprueba la validez de los parámetros de entrada
self.correcto()
-Comprueba el texto corriente de la opción de variable de barrido y lee el rango y el valor de
incremento de la variable seleccionada sobre los sus cuadros de texto correspondientes.
if (self.ui.Modos.currentText() == “nombre_variable_seleccionada”):
valormin = “valor_inferior_del_rango”….(tipo real)
valormax = “valor_superior_del_rango”….(tipo real)
incvalor = “valor_de_incremento”….(tipo real)
-Obtiene los 3 valore de frecuencia que se han introducido en el 2º paso y se almacenan todos
los valores de barrido de la frecuencia en una lista.
uno=[]
a1=float(self.ui.frecEstudio1.text())
b1=float(self.ui.frecEstudio2.text())
while a1<=b1:
uno.append(a1)
a1 = a1 + float(self.ui.incfrec.text())
Valor superior del rango de frecuencias
Valor inferior del rango de frecuencias
Método de listas para
añadir valores.
Lista donde se almacenan
todos los valores del rango de
frecuencias.
1 de 4

-Se habilita la barra de progreso para que indique el estado del cálculo dándole un rango comprendido entre el
valor mínimo de la frecuencia y el valor máximo.
self.ui.progressBar.reset()
self.ui.progressBar.setMinimum(“valor_del_rango_mítnimo”..(tipo entero))
self.ui.progressBar.setMaximum(“valor_del_rango_máximo”..(tipo entero))
-Se deshabilitan todos los cuadros de texto correspondientes a los parámetros de entrada.
self.ui.”nombre_cuadro_de_texto”.setEnabled(False)
-Se crea un fichero de almacenamiento de datos provisional “GTRfinlinep.txt” a modo de escritura.
f=open('graficasGTRfinlinep.txt','w+')
-Se crea una iteración donde se creará el fichero de datos “gtrfinin.dat” y se “lanzará” el motor de cálculo
tantas veces como valores de frecuencia hay en la lista uno[].
for fre in uno:
-Se crea el fichero de entrada de datos a modo de estritura “gtrfinin.dat” en el mismo
subdirectorio donde se encuentra el motor FORTRAN “gtrfin.exe”
-Se “lanza” el motor de cálculo FORTRAN “gtrfin.exe”.
currentworkingdirectory=os.getcwd()
file=os.path.join(os.getcwd(),'GTR')
os.chdir(file)
file='gtrfin.exe'
os.spawnv(os.P_WAIT,file,(file,))
os.chdir(currentworkingdirectory)
-Para que el motor FORTRAN lea el fichero de
entrada, debemos modificar el directorio de
trabajo en la dirección donde se encuentra el
motor y su fichero de entrada, de lo contrario,
el motor buscará el fichero inexistente en el
directorio de trabajo de la ventana principal.
-Una vez ejecutado se cambia el directorio de
trabajo a su dirección original.
-Esta función lanza el
ejecutable.
-Se debe esperar su
finalización antes de leer
el fichero de salida
(os.P_WAIT)
2 de 4

-Extraemos los datos del fichero de salida “gtrfin.dat”.
-Se tienen en cuenta todos las posibles excepciones y errores en la lectura
del archivo “gtrfin.exe”.
-Se almacenan los datos en corregidos en un orden concreto dentro del fichero
provisional “GTRfinlinep.txt”
f.write(“datos_corregidos”)
-Dimensiones
variables de la
etiqueta explicativa
del fichero.
-A menudo se juntan dos resultados haciendo
imposible su lectura directa
-Se pueden pegar dos resultaods, la longitud
máxima del valor el de 15 caracteres si es negativo
y 14 caracteres si es positivo.
El número de valores
calculado por cada
posibilidad puede ser
mayor a 1 o nulo
El motor escribe el la cadena
“NaN” o “………” para un
resultado imposible.
-Se desestima la línea.
En el caso que exista,
parte real e imaginaria
de los parámetros
calculados
Nota: aún nos
encontramos en el
interior de la iteración
for fre in uno:
3 de 4

-Se deshabilita el botón pulsable “CalculaPropagación”. No se desea repetir los cálculos accidentalmente
-Según la variable de barrido seleccionada se habilitarán los botones de gráficas respectivos y se añadirán los
“items” correspondientes en los cuadros de combinaciones respectivos. Esto permite seleccionar un valor
constante de las variables de barrido.
if self.ui.modo == (“variable_barrido_seleccionada”):
self.ui.”nombre_botón_gráfica_respectivo”.setEnabled(TRUE)
for m in (“matriz_que_contiene_los_valores_de_un_rango”):
self.ui.”nombre_cuadro_comginación”.addItem(m).
-Se habilita el botón de la barra de herramientas para poder guardar la simulación.
-Se indicará la página de la tabla de gráficos a la que hay que ir cargando el num. de página en
su cuadro de texto correspondiente.
-Se llama a la función self.graficoexplicativo() para actualizar si el necesario la imagen de la guía.
-Se crea el fichero “GTRfinline.txt” que contiene los datos definitivos a partir de los datos corregidos del
fichero provisional “GTRfinlinep.txt”.
…....
Se habilitan los
botones de gráficas
respectivos.
-Se añaden los “items”
respectivos en los cuadros
de combinaciones
-El método addItem() es
casi exclusivo del tipo
“QtGui.QComboBox”
GTRfinlinep.txt (provisional)
GTRfinline.txt (definitivo)
Regla de corrección
-Esto se debe a que el tamaño del registro
es limitado, lo cual puede arruinar el
orden concreto en que se han escrito los
datos en cada línea.
-Si la el contenido de la línea rebasa el
tamaño del registro, la parte sobrante se
escribirá inmediatamente abajo en una
línea diferente.
4 de 4

3.4 Se crea la función para guardar los datos de la simulación actual.
def guardar(self):
-Se abre un diálogo predefinido para guardar que ofrece la librería “QtGui” que devuelve un puntero hacia el
fichero seleccionado. Contiene el nombre de fichero y su ubicación.
fileName = QtGui.QFileDialog.getSaveFileName(self,
"Guardar archivo",
"C:Python24Libsite-packagespyanmuestreos",
"All Files (*);;Text Files (*.txt)")
-Se comprobará si el usuario ha introducido un nombre de archivo:
if not fileName.isEmpty():
-El puntero fileName, tiene como separador de subdirectorios el carácter “” que no es
reconocible por el lenguaje PYTHON.
-Igualamos el valor del puntero en una variable, ya que después de la asignación se libera.
t = fileName
-Modificamos el símbolo “” por “” (separador de directorios en PYTHON) y añadimos el
prefijo “gtr1_” al nombre del fichero sobre el contenido de “t”.
-Almacenamos en un orden concreto los parámetros de entrada de la simulación ya realizada y
seguidamente sus valores calculados en el fichero “t”.
En los argumentos del objeto
“.QfileDialog.getSaveFileNa
me”, introducimos el título de
diálogo, la ubicación donde
se localizará por defecto y el
formato de archivo que se
mostrará en la ventana.

3.5 Se crea la función para cargar los datos de una simulación realizada.
def cargar(self):
-El procedimiento inicial es exactamente el mismo que en el de la función def guardar (self): exceptuando que
ahora no se trata de llamar al método para guardar sino al método para cargara de la clase diálogo.
fileName = QtGui.QFileDialog.getOpenFileName(self,
"Abrir archivo",
"C:Python24Libsite-packagespyanmuestreos",
"All Files (*);;Text Files (*.txt)")
-Se controla si el nombre de fichero de entrada contiene el prefijo “gtr1_”.
-Se actualizan los valores de entrada de la aplicación según los valores que contiene el fichero de
entrada.
-Se limpia el posible contenido de los cuadros de combinaciones que contienen los valores del
rango de barrido de una posible simulación anterior.
Haremos servir esta sentencia self.ui.”nombre_cuadro_combinaciónes”.removeItem()
-Se cargan los nuevos valores en los cuadros de combinación correspondientes.
-Se deshabilitará los cuadros de texto correspondientes con el fin de no modificarlos mientras
visualicemos gráficas.
-Se deshabilitará el botón de cálculo.
-Se actualizará el valor de la barra de progreso.
-Se habilitará el botón para guardar.
-Se indicará la página de la tabla de gráficos a la que hay que ir cargando el num. de página en
su cuadro de texto correspondiente.
-Se lanzará la función self.graficoexplicativo() para refrescar la imagen de la guía de
ondas.

3.6 Se crea la función para realizar una nueva simulación.
def nuevo (self):
-Se importarán y inicializara a sus valores originales todas las variables globales.
-Se habilitarán todos los cuadros de texto y se restablecerá su configuración y contenido original.
-Se limpia el posible contenido de los cuadros de combinaciones que contienen los valores del
rango de barrido de una posible simulación anterior.
-Se deshabilitarán todos los botones para realizar gráficas.
-Se habilitará el botón de cálculo.
-Se reseteará el estado de la barra de progreso.
-Se deshabilitará el botón de guardar
-Se limpiará el contenido del cuadro de texto que indica la página de la tabla de gráficos.
-Se refrescará la imagen con los valores originales de las variables globales llamando a la función
self.graficoexplicativo()

3.7 Se crean las funciones encargadas de “lanzar” el ejecutable que crea las gráficas, y preparan el entorno
favorable.
def graficarEpsFremod(self):
-Se abre el fichero “GTRfinlinegr.txt” en el subdirectorio “gráficas a modo de escritura”
-Dentro de este fichero se escribirán los siguientes parámetos:
-Si se desea visualizar gráfica o gráfica con tabla de resultados.
f3.write ((self.ui.grafodat.currentText())+" n"
-El nombre del parámetro que se mantiene constante en la gráfica.
-El valor del parámetro que se mantiene constante en la gráfica.
-El título de la gráfica.
-El título del eje “X”.
-El título del eje “Y”.
Se almacenan desde el fichero “GTRfinline.txt” al fichero “GTRfinlinegr.txt” los parámetros a
ser mostrados en el siguiente orden.
Se comprueba si existe al menos un valor calculado para mostrar para el valor constante
seleccionado.
-En caso afirmativo se lanzará el ejecutable de “plotting” “GTRfinline.py”-
-En caso negativo se emitirá un pequeño diálogo modal prediseñado en la librería
QtGui indicándonos que seleccionemos otro valor constante.
Nombre de la
variable a
mostrar.
Nombre de la
variable de
barrido
Nombre de la
variable constante
en el barrido
1º Todo el rango de valores
de la variable seleccionada
como constante
mostrados a lo largo del eje
de coordenadas “X”
mostrados a lo largo del eje
de coordenadas “Y”
Esta comprobación se
realiza aquí ya que
desde la clase
principal se pueden
activar estos sistemas
de apoyo.

3.8 Se crean las funciones de control particular para cada “widget” durante la entrada de datos.
Las funciones de control se actrivan con la señal “editingfinished()” (señal emitida cuando el cursor sale del cuadro de texto).
def ctrl”nombre_del_parámetro_de_entrada”(self):
-Se declara y actualiza la variable global asociada al parámetro.
-En caso necesario se declaran e inicializan las variables
globales dependientes al parámetro
-Se inicializa el contenido de los cuadros de texto
de las variables dependientes.
-Se llama a la función self.gráficoexplicativo() para refrescar el esquema de la guía con el nuevo parámetro
introducido.
-En caso necesario se emitirá un diálogo modal prefabricado advirtiéndonos de modificar las variables
dependientes una vez modificado el contenido de esta variable.
QtGui.QMessageBox.information(self , "Atencion", "No olvides cambiar los parámetros W y B1
teniendo en cuenta la BTmin")
Ejemplo: Evidentemente se producirá
una excepción si al modificar el ancho de
la guía, resulta más pequeño que el ancho
de la capa dieléctrica que contiene

3.9 Se crea una función de apoyo para advertir al usuario de un posible “excepción” en los datos que ha
introducido.
def correcto (self):
-Se declara la variable global “correcto”, que usará la función self.Calculacorte() para permitir o denegar el
proceso de cálculo.
-Se controla mediante las sentencias de gestión de excepciones la existencia de valores incoherentes.
try:
Se comprueban posibles incoherencias entre los parámetros de entrada.
correcto = TRUE
except:
Se emite un avisador pidiendo la revisión de los datos.
correcto = FALSE

6.4 Estructura de código del ejecutable de “plotting” “GTRfinline.py”
Código del ejecutable: “GTRfinline.py”. Sobrescribimos en código autogenerado.
1. Se importan bloques y librerías.
import “dirección_módulo”.“nombre_módulo”
from “dirección_módulo”.“nombre_módulo” import “nom_librería”
import matplotlit, spicy
2. Se abre el fichero “GTRfinlinegr.txt”
-Se extraen el título de la gráfica, del eje X (variable de barrido), del eje Y (variable a visualizar).
-Se extrae el valor de la variable seleccionada como constante y si quiere mostrar tabla o gráfica.
-Se extraen los parámetros calculados en filas con el orden siguiente:
3. Se crean la gráfica y la interfaz amigable para manejarla con los objetos proporcionados por las
librerías “matplotlib” y “spicy”.
Estas dos librerías proveen de elementos
autoconstructores para generar gráficas con
interfaz de usuario
1º Todo el rango de valores de
la variable seleccionada como
constante
mostrados a lo largo del eje de
coordenadas “X”
mostrados a lo largo del eje de
coordenadas “Y”
“valor_contante”
x.append( ) y.append( )
==
Si entonces entonces

6.4 Estructura de código del ejecutable de “plotting” “GTRfinline.py”
3. Se crea la gráfica y la interfaz amigable para manejarla con los objetos proporcionados por las librerías
“matplotlib” y “spicy”.
-Si se ha elegido mostrar el gráfico excusivamente.
if (grafodat=="Gráfico n"):
-Se genera una instancia llamando al método “plot()” que por si solo construye e inicializa el gráfico y su
interfaz amigable en TK. A partir de aquí añadimos los atributos a la clase generada (al igual que el método
_init_.())
plot( x , y , "-bo“ )
-Se define el tipo de letra:
font{}
-Se crea un texto que indica el nombre y valor de la variable selecionada como constante:
text()
-Se crea leyendas en el eje S y el eje Y.
xlabel(“nombre_variable_barrido”)
ylabel(“nombre_variable_a_mostrar”)
-Se da un título a la gráfica.
title(“nombre_título”)
-Se muestran por pantalla los elementos construidos.
show()
-Si se ha elegido motrar gráfico y tabla.
if (grafodat=="Talba resultados n"):
Ídem de lo anterior exceptuando que se incluye un objeto para construir tablas con resultados.
the_table()
Rango y valores
del eje “x”
Rango y valores
del eje “y”
Indicamos el
perfil de la
gráfica.
Nota importante: Este código ha
debido de hacerse externamente ya que
si es ejecutado desde la aplicación QT
provoca un bloqueo de esta

7. CONCLUSIONES
-1º Concluida la creación de I.G., podemos decir que hemos satisfecho nuestros
propósitos de crear una interfaz gráfica de usuario práctica y efectiva .
-2º Hemos proporcionado una herramienta gráfica y didáctica para el análisis de
guias de onda a partir de los métodos numéricos SDA [1], GTR [2] y TLM [3] .
Además de implementar una aplicación (SYZ) que permite transformar
parámetros dados entre tres tipos distintos, S, Y y Z.
-3º Hemos establecido una nueva vía de programación para crear aplicaciones
gráficas mediante un lenguaje prácticamente desconocido en el entorno de la UPC:
el PYTHON, y mediante la plataforma de diseño de elementos gráficos QT.
-4º Hemos dejado abierta la posibilidad de ampliar las aplicaciones de I.G. debido
a la enorme cantidad existente de métodos para el análisis de modelos de
discontinuidades en guías de onda

BIBLIOGRAFÍA
[1] - Título: “Numérical Techniques for Microwave and Milimeter-Wave Passive Structures”; Editor: Tasuo Itoh 1984;
Capítulo 12: “Spectral Domain Approach”, Autor: R. Sorrentino/ Department of Electronic Engineering, Universitá di
Roma Tor Vergata.
Capítulo 11: “Tranverse Resonance Technique”; Apartado: 3: “Generalized transverse resonance”, pags “650-658”-
Autor: R. Sorrentino/ Department of Electronic Engineering, Universitá di Roma Tor Vergata.
[3] -Título: “Numérical Techniques for Microwave and Milimeter-Wave Passive Structures”; Editor: Tasuo Itoh 1984;
Capítulo 8: “Transversal Line Matrix”, Autor: Tatsuo Itoh/ aDepartment of Electrical and Computer Engineering, The
Univesity of Texas at Austin.
[4] - En la url: http://es.wikipedia.org/wiki/Fortran, encontraremos información sobre la autoría y el propósito del
lenguaje de programación FORTRAN.
[5] En la url: http://es.wikipedia.org/wiki/Qt_(biblioteca), podrá encontrar información sobre esta biblioteca
multiplataforma para desarrollar interfaces gráficas de usuario.
[6] -En la url: http://es.wikipedia.org/wiki/Python, encontraremos información sobre el autor y propósito del lenguaje de
programación PYTHON.
[7] –En la url: http://es.wikipedia.org/wiki/Tk, se podrá encontrar información descriptiva sobre esta biblioteca
multiplataforma para el desarrollo de aplicaciones gráficas.
[8] -En la url: http://linux-itt.blogspot.com/2008/01/python-tipos-de-datos-bsicos.html, encontraremos información sobre
los tipos de “Complex” para máqunas 64 bits y máquinas de 32 bits.
[9] -Mark Pilgrim, "Dive Into Python" (2005). Capítulo 1: “Installing Python”; Apartado 1.1: “Which Python is right for
you?”; pag: 6.

[10] - En esta url: http://numeric.scipy.org/, encontramos un paquete numérico (de funciones de cálculo), “arrays”, y
tratamiento con complejos.
[11] -En al url: http://numeric.scipy.org/, encontraremos el paquete o módulo “numarray” además de una amplia descripción.
[12] -En al url: http://numeric.scipy.org/, encontraremos el paquete o módulos “numpy” además de una amplia descripción.
[14] -En esta web: http://www.lawebdelprogramador.com y en la web http://mmm-experts.com/, encontramos unos foros
extremadamente útiles sobre ayudas a la programacion en PYTHON.
[15] -Mark Pilgrim, "Dive Into Python" (2005). En esta url: http://diveintopython.org/, encontramos una guía muy extensa
sobre la sintáxis del lenguaje escrita en español e inglés (versión más completa).
[17] -En esta url: http://www.riverbankcomputing.co.uk/pyqt/, encontraremos el modulo QT para PYTHON.
Capítulo 11: “Tranverse Resonance Technique”; Apendice1: “SLABGUIDE”, pags - Autor: R. Sorrentino/ Department of
Electronic Engineering, Universitá di Roma Tor Vergata.
[19] –En esta url: http://www.commandprompt.com/community/pyqt, donde encontramos el libro con título: “GUI
Programming with Python: QT Edition”; capítulo 7: “Signals and slots in depth”.

Presentació1 (1).ppt interfaces graficas

Recomendados

Recomendados

Más contenido relacionado

Similar a Presentació1 (1).ppt interfaces graficas

Similar a Presentació1 (1).ppt interfaces graficas (20)

Más de yannaRodrguez

Más de yannaRodrguez (17)

Último

Último (20)

Presentació1 (1).ppt interfaces graficas