Report

Software para la gracacin de diagramas termodinmicos
Proyecto Integrador de Ingeniera en Computacin
Martn Gaitn
Abril de 2011
Director Mg. Gustavo Wolfmann Codirector Dr. Martn Cismondi Duarte
A Nati y a mi familia, por todo el amor
II
ndice general
1. Introduccin 1.1. Descripcin 1.2. Motivacin 1.3. Importancia 1.4. Alcance . . 1.5. Objetivos .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
1 1 2 3 3 3 5 5 6 8 9
2. Marco Terico 2.1. Diagrama de fases de sistemas binarios 2.2. Equilibrio termodinmico . . . . . . . 2.3. Ecuaciones de Estado . . . . . . . . . 2.4. Aplicacin y utilidad . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
3. Contexto de trabajo 11 3.1. Trabajo interdisciplinario . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 3.2. Software libre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 4. Ingeniera de requerimientos 4.1. Metodologa de relevamiento . . . . . 4.2. Relevamiento de la versin preexistente 4.3. Especicacin de requerimientos . . . 4.4. Requerimientos especiales . . . . . . . 4.5. Casos de uso . . . . . . . . . . . . . . 17 17 17 22 23 25
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
5. Metodologa 29 5.1. Metodologas giles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 5.2. Desarrollo evolutivo adaptado . . . . . . . . . . . . . . . . . . . . . . . . . . 30 5.3. Modelado conceptual vs. UML . . . . . . . . . . . . . . . . . . . . . . . . . 30 6. Tecnologas adoptadas 33 6.1. Lenguaje de programacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 6.2. NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
III
6.3. 6.4. 6.5. 6.6. 6.7. 6.8. 6.9.
Matplotlib . . . . . . . . . . . . . WxPython . . . . . . . . . . . . . El patrn Publish/Subscribe . . . . Gestin de proyecto . . . . . . . . Control de versiones . . . . . . . . Seguimiento de errores y propuestas Documentacin . . . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
39 40 43 45 46 47 47 49 49 50 51 51 53 56 59 59 64 66 69 72 79 84
7. Arquitectura 7.1. Modelo conceptual . . . . . . . . . . . 7.2. Componentes y capas de software . . . 7.3. Capa de base de datos . . . . . . . . . 7.4. Diagrama de paquetes . . . . . . . . . 7.5. Diagramas de clases . . . . . . . . . . 7.6. Preceptos adoptados en el diseo de UI
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
8. Implementacin 8.1. Utilizacin de Publish/Suscribe en GPEC 8.2. Invocacin de ejecutables del backend . . 8.3. Memorizacin de resultados costosos . . 8.4. Algoritmo de anlisis sintctico . . . . . 8.5. Interfaz Grca de Usuario (GUI) . . . . 8.6. Integracin Matplotlib-WxPython . . . . 8.7. Implementacin de base de datos . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
9. Vericacin 87 9.1. Conceptos de pruebas unitarias . . . . . . . . . . . . . . . . . . . . . . . . . 87 9.2. Pruebas realizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 9.3. Pruebas de usabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 10. Implantacin 93 10.1. Empaquetado para sistemas Windows . . . . . . . . . . . . . . . . . . . . . . 93 10.2. Instalacin en sistemas Linux . . . . . . . . . . . . . . . . . . . . . . . . . . 97 10.3. Distribucin y soporte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 11. Conclusiones 11.1. Resultados . . . . . . . . . . . . . . . . . . . . 11.2. Observaciones respecto a la tecnologa empleada 11.3. Problemas detectados . . . . . . . . . . . . . . 11.4. Tiempo de desarrollo . . . . . . . . . . . . . . . 11.5. Costo de desarrollo . . . . . . . . . . . . . . . . 11.6. Impacto . . . . . . . . . . . . . . . . . . . . . . 11.7. Experiencia de trabajo . . . . . . . . . . . . . . 11.8. Lneas de trabajo abiertas . . . . . . . . . . . . A. Ejemplos de diagramas Bibliografa 99 99 100 100 101 101 102 103 104 107 111
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
IV
B. Especicacin de la interfaz de comunicacin B.1. Tabla de incidencia . . . . . . . . . . . . B.2. CONPAROUT.DAT . . . . . . . . . . . B.3. GPECIN.DAT . . . . . . . . . . . . . . B.4. GPECOUT.DAT . . . . . . . . . . . . . B.5. TFORPXY.dat . . . . . . . . . . . . . . B.6. PXYOUT.DAT . . . . . . . . . . . . . . B.7. PFORTXY.DAT . . . . . . . . . . . . . B.8. TXYOUT.DAT . . . . . . . . . . . . . . B.9. ZforIsop.dat . . . . . . . . . . . . . . . B.10. ISOPOUT.DAT . . . . . . . . . . . . . . B.11. FUGIN.DAT . . . . . . . . . . . . . . . B.12. FUGOUT.DAT . . . . . . . . . . . . . . B.13. IsoXTin.DAT . . . . . . . . . . . . . . . B.14. IsoXTout.DAT . . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
115 115 118 118 120 122 123 123 123 124 124 125 125 126 126
C. Glosario 127 C.1. Qumica y termodinmica . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 C.2. Computacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 ndice 133
VI
CAPTULO 1
Introduccin
En sus orgenes y durante muchas dcadas, la computacin estuvo vinculada estricta e intrnsecamente al mundo de la ciencia. Este vnculo fue retroalimentndose a lo largo de la historia, permitiendo tecnologas que abarataron y multiplicaron la potencia de las computadoras y, en el otro sentido, ayudando a resolver complejos interrogantes que sin la capacidad computacional los cientcos no hubieran podido responder. Es evidente que en la actualidad las computadoras ya no son exclusividad de selectos laboratorios o universidades y su uso generalizado ha modicado drsticamente la cultura y la calidad de vida de las personas, teniendo un rol sine qua non en el trabajo, la comunicacin, el ocio, etc. Esta popularizacin abri amplsimos campos de desarrollo de la computacin, pero, aunque ya no el nico, el campo de la computacin cientca sigue siendo de gran importancia. Diversas reas de la ciencia y la ingeniera han sido revolucionadas por el software para clculo, visualizacin y simulacin disponible. Por nombrar slo dos ejemplos, herramientas como MATLAB o Mathematica forman parte del da a da en la labor de ingenieros e investigadores. En este mbito de aplicacin puede hacerse una distincin entre software cientco/tcnico de propsito general como los mencionados (independientemente de que tengan mayor aceptacin en un campo u otro) de los que son de propsito especco y realizan un conjunto de tareas puntuales (software aplicativo). Este trabajo se incluye en la segunda categora ya que se trata de una aplicacin cientca multiplataforma, con interfaz grca de escritorio, que basada en programas de clculo preexistentes permite realizar diagramas de equilibro de fase en 2 y 3 dimensiones que son de suma utilidad para la enseanza, la investigacin y la aplicacin industrial.
1.1 Descripcin
GPEC (Global Phase Equilibrium Calculations) 1 , es un software para la obtencin de curvas de equilibro termodinmico de fase global para sistemas binarios, que se calculan mediante ecuaciones de estado. Es til para nes acadmicos, cientcos y de desarrollo industrial.
1
Web: http://gpec.efn.uncor.edu
Software para la gracacin de diagramas termodinmicos GPEC fue desarrollado originalmente en el ao 2005 por el Dr. Martn Cismondi Duarte, codirector de este trabajo, en el marco de su tesis doctoral 2 en Ingeniera Qumica por la Universidad Nacional del Sur, parte de la cual fue cursada en la Universidad Tcnica de Dinamarca 3 . Luego fue ampliado junto a Diego Nuez. Est basado en mtodos numricos y algoritmos desarrollados principalmente por Cismondi en colaboracin con el Prof. Michael Michelsen, del Department of Chemical Engineering, DTU (Dinamarca), y el Prof. Marcelo Zabaloy de la Universidad Nacional del Sur, (Argentina). Actualmente es un proyecto dirigido por el Prof. Esteban Brignole de PLAPIQUI (Planta Piloto de Ingeniera Qumica) 4 en colaboracin con el IDTQ (Investigacin y Desarrollo en Tecnologas Qumicas) 5 El software tiene una arquitectura de capas con un mecanismo de comunicacin. El Back end corresponde al conjunto de programas (codicados en lenguaje Fortran) que implementa los algoritmos de clculo . El Front end, denominado Visual Gpec es la interfaz de usuario que genera datos de entrada con formato comprensible por los algoritmos y procesa las salidas generando distintos grcos. Para detalle sobre esta arquitectura puede ver Modelo conceptual. Para mayores detalle sobre la versin preexistente de GPEC vea Relevamiento de la versin preexistente. Importante: Estrictamente, GPEC es el conjunto de aplicaciones de clculo desarrolladas por Cismondi Con el advenimiento de la primera interfaz grca Visual Gpec, se comenz a llamar GPEC al conjunto de software, y es, salvo aclaracin explcita, la asepcin que tiene en este libro.
1.2 Motivacin
GPEC es un software que goza de cierta popularidad en el ambiente cientco- acadmico. Se utiliza, por ejemplo, en el curso intesivo de postgrado High Pressure Technology in Process and Chemical Industry en el marco del programa Socrates Erasmus de la Unin Europea 6 . Dicho curso se dicta iterativamente en distintas universidades europeas de Alemania, Italia, Espaa, Holanda, etc. Hasta el momento no se conoce ningn otro software con capacidades equivalentes, lo que implica una creciente comunidad de usuarios, pertenecientes no slo a instituciones acadmicas y de investigacin, si no tambin a industrias.
Un resumen de la tesis es el artculo Global phase equilibrium calculations: Critical lines, critical end points and liquid-liquid-vapour equilibrium in binary mixtures, M Cismondi, ML Michelsen - The Journal of Supercritical Fluids, 2007 3 DTU - Danmarks Tekniske Universitet. Web http://www.dtu.dk/ 4 Es un instituto de investigacin, educacin y desarrollo de tecnologa con sede en la ciudad de Baha Blanca, dependiente de la Universidad Nacional del Sur (UNS) y del Consejo Nacional de Investigaciones Cientcas y Tcnicas (CONICET). Web: http://www.plapiqui.edu.ar 5 Grupo de investigacin de la Facultad de Ciencias Exctas Fsicas y Naturales. Web: http://www.idtq.efn.uncor.edu 6 http://atom.uni-mb.si/Labs/lab_sep/socrates.htm
2
Captulo 1. Introduccin
Sin embargo, algunos factores han sido determinantes para el virtual congelamiento de su desarrollo desde el ao 2008. En particular: La falta de recursos tcnicos especializados en el desarrollo de software vinculados a los grupos que impulsan GPEC La ausencia de documentacin La complejidad que ha alcanzado el proyecto El diseo cerrado, no reutilizable y poco extensible adoptado Ver Tambin: Problemas detectados
1.3 Importancia
Las potencialidades tcnicas, cientcas e incluso comerciales de este software son amplias, ya que tiene aplicacin en la industria alimenticia, petroqumica, hidrocarburifera, etc. Tambin es til como herramienta educativa, donde los estudiantes consolidan conceptos tericos y manipulan parmetros obteniendo una visualizacin interactiva de los resultados. Ver Tambin: Para un detalle sobre este aspecto vea Aplicacin y utilidad
1.4 Alcance
El alcance de este trabajo es el rediseo y la implementacin de una nueva aplicacin de generacin de grcos para GPEC, cubriendo y superando las prestaciones ofrecidas hasta el momento, contemplando los mecanismos de comunicacin con el software de clculo subyacente sin alterarlo de manera alguna.
1.5 Objetivos
1.5.1 Objetivo general
El objetivo principal que persigue este trabajo es: Desarrollar un software front end totalmente compatible con el back end existente que reemplace al actual (Visual Gpec), orientado a un desarrollo prolongado y extensible, basado en un lenguaje de programacin moderno y bibliotecas en desarrollo activo. Debe satisfacer las funcionalidades con las que la versin actual cuenta, amplindolas y mejorndolas en algunos aspectos como la ergonoma, la calidad de los diagramas producidos, la usabilidad general, y aspecto visual del programa.
1.3. Importancia
1.5.2 Objetivos especcos

Los objetivos especcos del proyecto son: Estudiar y documentar la versin preexistente del software. Vea Relevamiento de la versin preexistente. Estudiar y documentar el mecanismo de comunicacin entre el front end y el back end . Vea Especicacin de la interfaz de comunicacin. Dilucidar fallas de diseo desde el punto de vista del usuario e idear sus soluciones para incluirlas como nuevos requerimientos. Relevar nuevos requerimientos. Investigar metodologas, procedimientos y paradigmas del desarrollo de software y justicar las adoptadas para este proyecto Investigar tecnologas (lenguajes de programacin, bibliotecas de funciones, etc) y justicar las adoptadas. Codicar y documentar el proyecto de manera que satisfaga el conjunto de requerimientos planteados. Vericar y validar la implementacin. Ver Tambin: Especicacin de requerimientos
Captulo 1. Introduccin
CAPTULO 2
Marco Terico
Debido a la naturaleza multidisciplinaria de este trabajo posiblemente sea ledo y evaluado por profesionales o interesados de/en las distintas reas de incumbecia (qumica y computacin). Ver Tambin: Trabajo interdisciplinario. Dado que no necesariamente se tiene un conocimiento slido fuera de la especicidad de la profesin, en este captulo se presentarn conceptos generales de termodinmica y equilibrio de fases (que no pretenden exhaustividad pero s precisin) . Para denicines de trminos puntuales, consulte el glosario. Como complemento, en Tecnologas adoptadas se ver una introduccin a las tecnologas, intentando un desarrollo de los conceptos apto para la comprensin de todos los lectores.
2.1 Diagrama de fases de sistemas binarios

Un diagrama de fase es un tipo de grco utilizado para mostrar las condiciones en las que distintas fases termodinmicas de un sistema pueden ocurrir en equilibrio. Se representa en funcin de variables que caracterizan el estado intensivo del sistema sicoqumico. El estudio introductorio de la termodinmica se centra en sustancias puras o mezclas a composicin constante. En este caso, el sistema es descripto por dos variables. Un diagrama de fase tpico para estos sistemas, es el Presin vs. temperatura que muestra la Figura 2.1.
As, para determinada presin y temperatura, la sustancia o mezcla constante puede estar en fase lquida, gaseosa o slida, o bien en un punto crtico. Es decir, qu porcentaje o fraccin de la mezcla corresponde a cada una de las dos sustancias del sistema. La composicin habitualmente se mide en fraccin molar, fraccin masa, o concentracin molar. Para sistemas binarios (una mezcla de dos componentes) la composicin (o, complementariamente, la densidad) se vuelve una variable del sistema, cuya representacin grca son curvas
Figura 2.1: La lnea verde indica los puntos de congelamiento. La azul los de ebullicin. La lnea punteada muestra un comportamiento particular del agua. en el espacio R3 (grco tridimensional) como muestra la gura 2.2. Para un determinado estado T-P-x (x es composicin, en general expresada como fraccin molar del compuesto ms voltil) el sistema se encuentra en zonas de equilibrio vapor/lquido, lquido/lquido, vapor/slido, lquido/slido u otros casos particulares.
La proyeccin ortogonal de estas curvas tridimensionales sobre los planos correspondientes genera los grcos cartesianos bidimensionales PT, Px, Tx (y sus anlogos para densidad) que son tpicos de la bibliografa del tema. Un ejemplo de proyeccin Temperatura vs. Composicin se muestra en la gura 2.3. El comportamiento termodinmico de los sistemas binarios no es uniforme cualquiera sean los compuestos de la mezcla. Existen seis tipos de comportamiento, de los cuales los tipos I, II, III y IV (enumerados en orden creciente de complejidad) son los ms comunes (todos calculables a travs de GPEC). Esta complejidad creciente del comportamiento se observa en la aparicin de equilibrios lquido-lquido, lquido-lquido-vapor, lneas azeotrpicas, etc.
2.2 Equilibrio termodinmico

Segn [SM-VN-AG2000] : (...) se reconoce al equilibrio como una condicin esttica donde, con el tiempo, no ocurre cambio alguno en las propiedades macroscpicas de un sistema, lo cual implica un balance de todos los potenciales que pueden ocasionar un cambio. 6 Captulo 2. Marco Terico
Figura 2.2: Un diagrama P-T-x para un sistema binario de Tipo I.
Figura 2.3: Un diagrama T-x para un sistema binario, mostrando la lnea crtica y otras informaciones.
2.2. Equilibrio termodinmico
Figura 2.4: Representacin de diagramas P-T para los primeros 4 tipos de comportamiento Por ejemplo, un sistema aislado que consta de las fases en contacto estrecho lquido y vapor, con el tiempo alcanza un estado nal donde no existe tendencia a que suceda un cambio en s mismo. La temperatura, la presin y las composiciones de fase logran los valores nales que en adelante permanecen jos, por lo que el sistema logra el equilibrio 1 .
2.3 Ecuaciones de Estado

El modelado cuantitativo de los equilibrios de fases se realiza principalmente utilizando ecuaciones de estado (E O S (Equation of State)). Estas son relaciones matemticas (modelos matemticos) entre dos o ms funciones de estado asociadas a la materia como la temperatura, la presin, el volumen o la energa interna. Como ejemplo conocido en cualquier curso introductorio de qumica, la Ley del gas ideal (2.1) es una ecuacin de estado, que al considerar el volumen molecular nulo y a las fuerzas de atraccin-repulsin despreciables, limita su utilidad para modelar gases reales.
pV = nRT
(2.1)
p es la presin absoluta, V el volumen, T la temperatura, n la cantidad de materia y R la constante del gas ideal.
A pesar de eso, en el nivel microscpico las condiciones no son estticas. Las molculas contenidas en una fase en un determinado instante son diferentes a las que despus ocuparan la misma fase, es decir, existe intercambio de de molculas en la zona interfacial, aunque al ser de igual rapidez promedio en ambas direcciones no ocurre transferencia neta de material.
1
Captulo 2. Marco Terico
Software para la gracacin de diagramas termodinmicos La Ecuacin de Van der Waals (2.2) (1873) 2 generaliza la ecuacin (2.1), teniendo en consideracin tanto el volumen nito de las molculas de gas como la atraccin intermolecular que afectan al trmino de presiones P+ a ( b) = RT 2 (2.2)
a y b son constantes fsicas de la sustancia en cuestin. Muchas de las ecuaciones de estado modernas son mejoras y correcciones a la ecuacin original de Van der Waals (denominadas ecuaciones de estado cbicas). Por ejemplo la ecuacin de Soave-Redlich-Kwong (1972), Peng-Robinson (1976), Elliott-Suresh-Donohue (1990), etc. GPEC es capaz de realizar los clculos usando cinco diferentes ecuaciones de estado (ver :ref:Requerimientos funcionales).
2.4 Aplicacin y utilidad

Los equilibrios entre fases tienen un rol muy importante en la tecnologa qumica, alcanzando una gran diversidad de aplicaciones, principalmente en procesos de separacin de la industria qumica, petroqumica y el sector de hidrocarburos, pero tambin en novedosos procesos basados en udos supercrticos, de gran desarrollo y creciente inters en las ltimas dcadas, como la generacin de co-cristales, la produccin de biodiesel, secado supercrtico, cromatografa supercrtica, etc. 3 . Especialmente a altas presiones estos equilibrios ser complejos de calcular e interpretar, por lo que la representacin a traves de diagramas de fases es esencial. Como ejemplicacin del inters de la industria y la academia sobre esta rea de investigacin, vale mencionar la experiencia del curso Advanced Course on Thermodynamic Models , dictada por los profesores Michael Michelsen y Jrgen Mollerup de la Universidad Tcnica de Dinamarca, que ha convocado a centenares de profesionales de diversas rmas como British Petroleum, Chevron, Phillips, Shell y muchas otras de renombre mundial. Este curso se realiz durante 2009 por primera vez en Latinoamrica, teniendo sede en la Universidad Nacional de Crdoba, organizado desde IDTQ, con participantes de Brasil, Canad, Chile, Alemania y varias otras procedencias 4 .
Por este descubrimiento, Van der Waals recibi el Premio Nobel de Qumica en 1910. Para un listado ms abarcativo, ver Supercritical uid: (http://en.wikipedia.org/wiki/Supercritical_uid#Applications) 4 Ver http://www.course.efn.uncor.edu/
3
Applications
2.4. Aplicacin y utilidad
10
Captulo 2. Marco Terico
CAPTULO 3
Contexto de trabajo
3.1 Trabajo interdisciplinario

La ciencia de la computacin no trata sobre las computadoras ms de lo que la astronoma trata sobre los telescopios Edsger Dijkstra Como se describe en la introduccin, la computacin ha revolucionado todas las reas de la cultura y la investigacin moderna, incluyendo, por supuesto, a la ingeniera en todas sus formas. Puede decirse que la ingeniera en computacin (complementada con la ingeniera en sistemas) se ha constituido en una meta ingeniera requerida por todas las dems reas. Es aceptable pensar que, en general, un ingeniero en computacin puede desenvolverse profesionalmente sin conocimientos de termodinmica, pero un ingeniero qumico o mecnico avocado a esa rea tendr dicultades para progresar si no tiene cierta destreza en programacin y sistemas de informacin. No obstante, cuando se quieren alcanzar objetivos ms altos a nivel de software, la capacidad y formacin media en un profesional de otra rea se vuelve escasa: el desarrollo de software es una ingeniera por s misma, que va mucho ms all de la destreza en programacin. Es saludable entonces que profesionales idneos sean los encargados de ese aspecto especco del proyecto, interactuando y consultando cuestiones que conciernen al mbito de aplicacin, aportando ideas, desarrollando una acabada ingeniera de requerimientos y explicando de manera didctica cuando estos exceden o complejizan innecesariamente la implementacin. Por otro lado, desde el contexto acadmico y de investigacin, en la FCEF Y N no existe una notoria sinergia entre las distintas disciplinas 1 , cuyas ventajas expone el magster Antonio Rey Roque en [ARR2003]: Hablar de interdisciplinaridad en el contexto acadmico signica lograr un nivel adecuado de comunicacin, la integracin de paradigmas, la ruptura de concepcioSalvo quizs las ms cercanas, como electrnica y computacin, pero en una medida muy inferior a la que podra lograrse.
1
11
nes reduccionistas, el desarrollo de una cultura de aprendizaje colectivo. Presupone implicacin profesional, multiplicacin (no suma) de ideas conceptuales, metodolgicas, procedimentales; economa de esfuerzos, de carga profesional y evaluativa. Implica un proceso docente educativo gil, econmico y enriquecedor para los docentes; procesos de aprendizaje ms signicativos para los alumnos; relacin profesional ms rica y afectiva entre docentes. El escenario correspondiente a un trabajo interdisciplinario no implica, como algunos pueden pensar, un mayor trabajo, sino, mayor riqueza, variedad y aceptacin de actividades; mayor equidad en la distribucin de tareas y recibe los benecios afectivos y profesionales del trabajo en equipo. El resultado del aprendizaje en tal escenario es un saber ms coherente, se logra mayor capacidad para enfrentar problemas. Desde ambos puntos de vista, estas han sido las ideas que, desde el principio, guiaron este proyecto. Como se ver en Experiencia de trabajo, el resultado ha sido altamente satisfactorio.
3.2 Software libre

El desarrollo de este trabajo ha sido liberado como Software Libre, bajo los te rminos de la bajo la licencia libre GPL (General Public License) 2 . Por su parte, este documento se ofrece bajo los trminos de la licencia Creative Commons Atribucin-NoComercial-CompartirIgual 2.5 <http://creativecommons.org/licenses/by-nc-sa/2.5/ar/>. Se dar a continuacin una somera introduccin conceptual al Software Libre, y en Justicacin se exponen los argumentos de la decisin mencionada, que se invita a leer y analizar. Importante: La liberacin se limita al software desarrollado por el autor de este trabajo, siendo este dependiente del backend GPEC que no es libre. Si bien la utilidad de un sofware libre que depende de otro no libre es parcial, (ver [RMS2004]), queda fuera de la potestad del autor la determinacin de una liberacin total, aunque enfticamente la promueva.
3.2.1 Introduccin
El Software Libre (SL) es aquel que respeta la libertad de los usuarios sobre su producto adquirido (independientemente de si se debe pagar por ello o no) y, por lo tanto, una vez obtenido puede ser usado, copiado, estudiado, cambiado y redistribuido libremente 3 . Esto no implica que el/la autor/a o autores del software pierdan los derechos de autora intelectual que son inalienables e imprescriptibles. La denicin de SL [FSFa] fue concebida originalmente por Richard Stallman a mediados de los aos 80, oponindose a las restricciones que impona el modelo de software privativo (SP) que muchas universidades empezaban a adoptar y que los hackers 4 no podan aceptar.
2 3
Licencia pblica general versin 3, http://www.gnu.org/licenses/licenses.html#GPL Reere a las cuatro libertades esenciales del software libre descriptas en [FSFa] 4 La nocin de hacker que el comn de la gente tiene es incorrecta. Vea el glosario para una denicin correcta.
12
Captulo 3. Contexto de trabajo
Desde entonces, y en especial con la aparicin del sistema operativo GNU/Linux, el avance del SL ha sido arrollador, siendo eslabn escencial para el funcionamiento de Internet desde sus orgenes hasta nuestros das 5 , de los clusters ms poderosos 6 y ncleo propulsor de los dos sitios ms visitados y exitosos a nivel mundial: Google 7 8 y Facebook 9 .
Figura 3.1: Familia de S.O. de los 500 supercomputadores ms rpidos del mundo. http://www.top500.org
De cierta manera, el SL ha excedido su condicin de forma de licenciamiento de software erigindose en un marco de referencia moral, poltico y legal para la creacin de conocimiento en sus diversas formas. Iniciativas como Creative Commons (http://creativecommons.org/) y Wikipedia (http://wikipedia.org/) nacieron como extensin conceptual aplicada a otros tipos de creaciones intelectuales.
3.2.2 Justicacin
Entre los muchos motivos que hacen al SL un modelo tcnicamente viable, econmicamente sostenible y socialmente justo [JMiH2005], sintticamente se mencionarn los que justican que el software desarrollado para este trabajo haya sido liberado.
En 2010, el 73 % de los servidores web funciona con software libre. http://news.netcraft.com/archives/2010/02/22/february_2010_web_server_survey.html 6 Hasta marzo de 2011, el 91.8 % de los 500 supercomputadores ms poderosos del mundo funcionaban con Linux o derivados. http://www.top500.org/charts/list/36/osfam 7 Sergey Brin en una entrevista de 2000 cuenta que dentro de Google Linux se utiliza en todas partes... en los ms de 6.000 servidores as como en las mquinas de todos nuestros empleados tcnicos (...) Es tan agradable poder adaptar cualquier parte del sistema siempre que quieras.. http://www.gazetadolinux.com/pr/lg/issue59/correa.html 8 Se estima que Google tiene en la actualidad ms de 200 mil servidores (http://www.googlelady.com/936/google-servers-googles-data-center/) . 9 Facebook has been developed from the ground up using open source software, http://developers.facebook.com/opensource/
5
3.2. Software libre
13
Creacin desde la Universidad Pblica La formacin del autor de este trabajo, as como la de su director y codirector, no obstante el esfuerzo personal, son fruto de la Universidad Pblica Argentina, privilegio al que una nma porcin de la sociedad accede cuando es ella toda, a travs del Estado, quien la sostiene. Ms an, el tiempo dedicado por los docentes para guiar y evaluar este trabajo fue sostenido con recursos pblicos 10 . Retribuir los conocimientos adquiridos en la formacin universitaria para benecio del conjunto del pueblo (y por extensin, de la humanidad), es una obligacin tica basada en la concepcin misma de la universidad pblica y gratuita, y declarada en el artculo 2 del Estatuto de la Universidad Nacional de Crdoba [UNC1] que enumera dentro de sus nes: la promocin de la investigacin cientca(...), [el] libre desarrollo de la cultura, (...) la efectiva integracin del hombre en su comunidad, (...) [el] promover la actuacin del universitario en el seno del pueblo al que pertenece, (...) [y] la difusin del saber superior entre todas las capas de la poblacin. Desarrollo basado en software libre Los buenos programadores saben qu escribir. Los mejores, que reescribir (y reutilizar) Eric Raymond, [ER1997] En ninguna disciplina creativa se es absolutamente original. Basarse en las creaciones o ideas previas, que han sido probadas con xito, presume la posibilidad de llegar a ms ambiciosos y seguros resultados. Es un precepto que el software libre comparte con la ciencia, expresada en la frase atribua a Isaac Newton: Si he visto ms lejos es porque me par sobre hombros de gigantes 11 Eric Raymond, en su famoso ensayo The Cathedral and the Bazaar [ER1997], expresa la ventaja desde su experiencia como programador: Aunque no pretendo ser un gran programador, trato de imitarlos. Una caracterstica importante de los grandes de verdad es la vagancia constructiva. Saben que te darn un diez no por tu esfuerzo, sino por los resultados, y es casi siempre ms fcil empezar a partir de una buena solucin parcial que desde la nada ms absoluta. El lenguaje y las bibliotecas que se usaron para el desarrollo de este trabajo son libres 12 (ver Tecnologas adoptadas) y ampliamente probadas por numerosas aplicaciones que las utilizan. Adems, gran cantidad de ejemplos y buenas ideas aplicadas en este trabajo fueron extradas de cdigo libre disponible en internet.
Por supuesto, habiendo podido dedicar su tiempo a otras labores, los docentes aceptaron dirigir este trabajo voluntariamente, actitud por la que vale reiterar el agradecimiento del autor. 11 Segn la entrada en Wikipedia (http://en.wikipedia.org/wiki/Standing_on_the_shoulders_of_giants#Attribution_and_meaning) la cita corresponde a Bernard of Chartres. 12 Particularmente, sus licencias no exigen que el software producido o derivado deba ser liberado, como s ocurre con GPEC al adoptar una licencia GPL.
10
14
Sin la existencia de SL este trabajo hubiera sido muchsimo ms costoso, tanto en trminos de horas de desarrollo como en el costo de licencias de software privativo equivalente al utilizado, y hubiese resultado inalcanzable en el contexto de un proyecto integrador de grado. Retribuir el resultado de los benecios usufructuados para que otros puedan servirse resulta un evidente acto de justicia. Necesidad de transparencia en el software cientco Dan Gezelter, mentor de la iniciativa Open Science (http://www.openscience.org) resume en [DG2009] los objetivos del proyecto: Transparencia en metodologa experimental, observacin y recoleccin de datos Disponibilidad pblica y reusabilidad de los datos cientcos Accesibilidad pblica y transparencia de la comunicacin cientca Uso de herramientas basadas en web para facilidad la colaboracin cientca. Sobre el primer punto agrega: (...) Garantizar el acceso al cdigo fuente es realmente equivalente a publicar su metodologa cuando el tipo de ciencia que realiza implica experimentos numricos. Soy extremista en este punto, porque sin acceso a las fuentes de los programas que usamos, nos apoyamos en la fe a las capacidades de codicacin de otras personas para llevar a cabo nuestra experimentacin. En algunos casos extremos, (por ejemplo, cuando el cdigo de simulacin o archivos de parmetros son privativos u ocultados por sus dueos), la experimentacin numrica ni siquiera es ciencia. Un diseo experimental secreto no permite a los escpticos repetir (y con suerte vericar) su experimento y lo mismo ocurre con experimentos numricos. La ciencia debe ser vericable en prctica tanto como vericable en principio. 13 Si bien el software realizado por el autor no implementa los algoritmos de clculos numricos, es una buena prctica permitir la vericabilidad de que los resultados no se adulteran. Calidad del software La libertad de un software no garantiza su calidad per se, ni mucho menos la ausencia de errores, pero aumenta enormemente las posibilidades de alcanzar cotas altas en este aspecto. Segn Challet y Le Du en [CLD03] para hacer un software de cdigo privativo de igual calidad que su equivalente libre hacen falta ms y mejor calicados desarrolladores. El artculo plantea, desde un modelo matemtico, que en el SL la interaccin entre los usuarios y desarrolladores logra que los fallos sean eliminados a una velocidad mucho mayor que la que un grupo de programadores de software privativo de elite puede lograr. Esto radica en dos aspectos: la libertad de estudiar el cdigo permite a cualquiera encontrar errores en el programa y reportarlos, y la dinmica de comunidad que muchos proyectos
13
Traduccin del ingls propia del autor del trabajo.
3.2. Software libre
15
de software libre logran, donde el feedback entre usuarios y desarrolladores es constante y horizontal. Mejor estrategia comercial Un mito, muchas veces difundido por inters 14 o por ignorancia, es que no se puede lucrar con Software Libre, lo cual es falso. Por el contrario, en muchos escenarios, la adopcin de software libre resulta beneciosa para su maximizacin. Jordi Mas enumera en [JMiH2005] los principales modelos negocio que se han puesto en prctica en el SL con xito durante los ltimos aos. En particular, es importante destacar el modelo de desarrollo software como servicio. Sobre este modelo Mas comenta: (...) [son] empresas que se dedican a la consultora, desarrollo a medida de soluciones, formacin y soporte tcnico (...) Su valor diferencial respecto a las empresas tradicionales de servicios son los benecios que transmiten a sus clientes por el hecho de trabajar con tecnologas libres como acceso al cdigo fuente de las soluciones (...) En general, las empresas que mejor funcionan de este tipo son aquellas que se especializan en un rea concreta de conocimiento (...) Ser un especialista en un rea y ser reconocido como experto en la misma es una buena estrategia. Si bien el derecho a realizar modicaciones es concedido a todo el mundo, dentro del universo de personas o empresas capaces de llevar a cabo adaptaciones a medida (situacin plausible en un nicho tan especco como el de GPEC), los autores originales del software se encuentran en una ventaja competitiva obvia. Por otro lado, en nichos de software especcos y pequeos, la posibilidad de difusin (y en consecuencia de traccin de usuarios) que tiene un software son mucho mayores aprovechando la infraestructura comunicacional de la que el SL goza: por el mero hecho de ser libre (y resultar mnimamente interesante) se dar publicidad gratuita y, mejor an, espontnea, en numerosos sitios de noticias y foros de internet, puede incluirse en repositorios de software accesibles fcilmente desde sistemas operativos libres que facilitan la instalacin y la prueba, y ser albergado en sitios de referencia para cdigo libre como SourceForge (http://sourceforge.net) GitHub (http://github.com) o Google Code (http://code.google.com) con cientos de miles de visitas diarias. Ms y mejores usuarios repercute, como se ha visto, en ms calidad y prestigio, que se realimentan en un bucle virtuoso ampliando posibilidades de lucro, n que est fuera de los alcances de este trabajo pero no por ello descartado a futuro. Ver Tambin: Lneas de trabajo abiertas
14
Vea FUD en el glosario
16
CAPTULO 4
Ingeniera de requerimientos
4.1 Metodologa de relevamiento

Para el relevamiento de requerimientos se realizaron entrevistas informales con el comitente, una evaluacin exhaustiva de la versin preexistente y, basado en el modelo de Desarrollo evolutivo adaptado (que se explica en Marco Terico), sucesivas presentaciones de prototipos que se fueron adaptando segn las observaciones de la parte interesada. Adems se utiliz un issue tracker para permitir que los usuarios adviertan de errores en la versin en desarrollo o propongan mejoras o nuevas funcionalidades. El proceso de relevamiento incluy entrevistas con el desarrollador de Visual Gpec y con investigadores de PLAPIQUI involucrados, como desarrolladores o usuarios, en GPEC.
4.2 Relevamiento de la versin preexistente

4.2.1 Aspectos histricos
La versin previa de GPEC es una aplicacin para entornos Microsoft Windows (Windows 2000, Windows XP o superior) desarrollada en una arquitectura de dos bloques funcionales: 1. Clculos e implementacin de algoritmos numricos, desarrollados en Fortran 2. Interfaz de usuario, validacin y gracacin (frontend), desarrollado en Visual Basic Esta arquitectura respondi a dos cuestiones principales: La preexistencia de los programas de clculo (ejecutables sin interfaz de usuario) que desarroll el Dr. Martn Cismondi como tsis doctoral y mantiene hasta la actualidad, con la colaboracin del Dr. Marcelo Zabaloy y la supervisin del Dr. Esteban Brignole, La necesidad pragmtica de separar el desarrollo del Gpec visual, trabajo realizado por Diego Nuez, del mantenimiento e implementacin de nuevos algoritmos y ecuaciones de estado.
17
La labor de Diego Nuez se produjo en el marco de su pasanta en PLAPIQUI durante los aos 2004 y 2005.
4.2.2 Descripcin general

La interfaz visual de GPEC presenta al usuario una GUI para interactuar con los distintos parmetros del diagrama elegido, enva los parmetros a los algoritmos de clculo y procesa las salidas de estos generando y mostrando los diferentes diagramas.
Figura 4.1: Interfaz principal de Visual Gpec. Deniendo un sistema Methane-Methanol con la EoS RK-PR. La comunicacin con los algoritmos implementados en Fortran se realiza mediante archivos de texto plano en un formato cuya estructura ad hoc es bien conocida por las dos partes. Como se ver en breve, esta interfaz de comunicacin se ha respetado (ver Especicacin de la interfaz de comunicacin). Asimismo, los datos de salida que producen los algoritmos, son ledos por Visual Gpec desde archivos de texto para su posterior gracacin, que se realiza, segun manifest el comitente, mediante rutinas desarrolladas ad hoc para esta implementacin. Es decir, no se utiliza en ninguna biblioteca para estos nes, de modo que los grcos se generan mediante el trazado punto a punto sobre un widget tipo canvas. El control de escala, segmentacin y dems funcionalidades bsicas debi programarse desde cero. El resultado de esto, si bien es aceptable y funcional, implic muchas horas de desarrollo, con grcos slo 2D, poco congurables, que no se pueden vectorizar ni exportar.
4.2.3 Licenciamiento
Visual GPEC no tiene una licencia explicitada pero se trata de un freeware*, es decir, un tipo de software que se distribuye sin costo y est disponible para su uso por tiempo ilimitado. La ltima versin pblicamente disponible era la 2.0.
18
Captulo 4. Ingeniera de requerimientos
Figura 4.2: Visualizacion de un diagrama P-T para el sistema Methane-Methanol con modelo RK-PR. Hasta el momento, GPEC no es Software Libre ni Open source, ya que su cdigo fuente no est disponible.
4.2.4 Aspectos de ingeniera de software

Segn surge de las entrevistas realizadas, durante su desarrollo anterior, GPEC no adopt ninguna metodologa particular, salvo la concerniente a la separacin funcional de la aplicacin como se explic anteriormente. Un problema manifestado por el equipo de desarrollo es el del versionamiento, ya que era incontrolable la coherencia entre los cambios realizados por ms de un colaborador. Las modicaciones y los archivos circulaban por email entre uno y otro, pero sin lograr sistematizacin y control sobre quin cambi qu. y a qu versin de GPEC corresponde un determinado cdigo fuente.
4.2.5 Problemas detectados

Lenguaje Como se ha mencinado, el programa se codic en Visual Basic 6, que es un lenguaje lanzado en 1998 y ya no es soportado por Microsoft, la empresa creadora, proponiendo en su reemplazo .Net, su tecnologa ms moderna Visual Basic es un lenguaje limitado y de poca robustez (sufre un problema asociado con varias 4.2. Relevamiento de la versin preexistente 19
Software para la gracacin de diagramas termodinmicos libreras dinmicas 1 ), y con un pobre soporte de orientacin a objetos, que condiciona la arquitectura de cualquier software no trivial a ser engorrosa y poco able. Asimismo, queda zanjada la posibilidad de contar con una aplicacin multiplataforma nativa, ya que el lenguaje slo funciona sobre Windows. Calidad de los grcos Los grcos generados, como se ha comentado, no se generan en ningun formato de archivo de imgenes (vectorial o mapa de bits), sino que simplemente se gracan por pantalla, con una proporcin de 1 pixel por punto. La informacin faltante se completa con segmentos de recta. Esto acarrea la imposibilidad de exportar la imagen si no es a travs de una captura de pantalla, requiriendo al menos un mnimo tratamiento de recortado y adaptacin (por ejemplo del color de fondo, dependiente del tema de apariencia de Windows congurado por el usuario) con un programa de manipulacin de grcos. El resultado de esta operacin es un mapa de bits carente de calidad suciente para la impresin o la inclusin en un artculo cientco, por lo que, en general, los usuarios recurren a la obtencin de los datos numricos y realizan la gracacin con otro software especco como Origin o Microsoft Excel. Diseo y Usabilidad Un aspecto poco cuidado de Visual Gpec es su usabilidad, ofreciendo una experiencia de usuario anti-intuitiva.
Figura 4.3: Ventanas abiertas para obtener un nuevo compuesto desde la base de datos, para que sea listado y utilizable en el sistema.
1
Este problema es conocido como DLL Hell (inerno de las DLL). Ver http://es.wikipedia.org/wiki/DLL_Hell
20
A primera vista, la pantalla principal ofrece muchsimas opciones que tienden a abrumar al usuario inexperto. Muchos componentes de la interfaz, como la lista de compuestos, no son necesarios permanentemente, y aun as, sin razn objetiva justicable, no todos los compuestos presentes en la base de datos se exponen en este selector. En caso de necesitar un compuesto que no est all listado, el proceso de obtencin requiere interacturar con 3 formularios distintos. ) se encuentra en Por poner otro ejemplo, el botn principal para el inicio del clculo ( una barra de herramientas con otras funciones no obligatorias para la ejecucin. Es decir, las herramientas carecen de un contexto que facilite la ubicuidad. Base de datos La base de datos est implementada en formato Microsoft Jet 2 y su diseo de tablas es complejo innecesariamente, realizando diversas relaciones One-to-One con una misma clave principal. Por ejemplo, los nombres y las propiedades de un compuesto qumico se encuentran en tablas separadas.
Figura 4.4: Visualizacin de algunas estructuras y datos de la base de Visual GPEC mediante el utilitario gmdb2. Sumado a esto, dada la ineciencia del formato, el archivo de base de datos estndar (sin datos extras agregados por el usuario) ocupa 45.2Mb de espacio en disco.
Microsoft Jet Database Engine es un motor de base de datos utilizado por el gestor Microsoft Access, entre otros productos. Ver http://en.wikipedia.org/wiki/Microsoft_Jet
2
4.2. Relevamiento de la versin preexistente
21
4.3 Especicacin de requerimientos

4.3.1 Requerimientos funcionales
Todas las funcionalidades de la versin preexistente de GPEC deben igualarse y en lo posible mejorarse. Se detallan a continuacin: Generacin del sistema binario: seleccin de dos sustancias. Gestin de base de datos de constantes de compuestos qumicos. Se incluir una base de datos con el software que el usuario puede manipular. Adecuacin del formulario y archivo de entrada de parmetros para diferentes ecuaciones de estado (modelos) de base molecular 3 : Soave-Redlich-Kwong Peng-Robinson RK-PR Simplied Perturbed Hard Chain Theory Perturbed Chain Statistical Associating Fluid Theory (PC-SAFT) Generacin de suite de grcos 2-D: Diagrama global de equilibrio de fases: Presin - Temperatura (P-T) Temperatura - Composicin (T-x) Temperatura - Densidad (T-) Presin - Composicin (P-x) Presin - Densidad (P-) Isopletas: diagramas para composicin Z constante (rango denible [0, 1] ): Presin - Temperatura (P-T) Temperatura - Composicin (T-x) Temperatura - Densidad (T-) Presin - Composicin (P-x) Presin - Densidad (P-) Diagramas isotrmicos (Pxy): diagramas para temperatura T [K] constante 4 : Presin - Composicin (Pxy)
Para la parametrizacin de los datos de entrada para cada ecuacin de estado fue menenester documentar la Especicacin de la interfaz de comunicacin. 4 La validacin de los rangos dinmicos (que dependen de las constantes crticas de los compuestos del sistema) la realizan los algoritmos de clculo. El frontend se limita a reportar un error en la obtencin de los datos de salida.
3
22
Software para la gracacin de diagramas termodinmicos Presin - Densidad (P-) Diagramas isobricos (Txy): diagramas para presin P [bar] constante : Temperatura - Composicin (Txy) Temperatura - Densidad (T-) Generacin de suite de grcos 3-D: diagramas globales y de parmetros constantes automticamente superpuestos para cada caso: Presin - Temperatura - Composicin Presin - Temperatura - Densidad Superposicin de diagramas compatibles Gestin de proyectos (manipulacin mltiples casos de sistemas/modelo/grco) Gestin de persistencia de datos (abrir, guardar, etc.) Ejecucin multiplataforma: GPEC debe ser capaz de utilizarse en entornos Windows y Linux Exportacin de grcos
4.3.2 Requerimientos no funcionales

GPEC requiere exibilidad que permita la extensibilidad de funcionalidades. Para esto se apunta a una arquitectura lgica modularizada que permita incorporar o extender funcionalidades de manera accesible. Manipulacin de grcos accesible: zoom, rotacin, desplazamiento, ocultacin de curvas, etc. Calidad y formatos de grcos vlidos para publicaciones cientcas Congurabilidad de aspecto de los grcos Usabilidad y claridad de las interfaces: debe poder usarse intuitivamente
4.4 Requerimientos especiales

Se especican en esta seccin, de manera no formal, un conjunto de requerimientos de especial inters para el diseo del software.
4.4.1 Un proyecto, muchos casos

Una tarea frecuente del usuario (investigador) es la comparacin entre distintos casos de estudio. Esto puede ser, un mismo sistema binario con aplicando diferentes coecientes, las mismas condiciones con diferentes modelo de clculo, o bien directamente distintos sistemas.
4.4. Requerimientos especiales
23
Es decir que debe existir el concepto de proyecto como un conjunto de mltiples casos, gestionados desde una misma interfaz de usuario. Nota: Dado que se presta a confusin, vale reiterar que caso en el contexto es la conjuncin de un sistema binario, un modelo de clculo (ecuacin de estado) y sus respectivos parmetros, y caso de uso reere al mbito de la ingeniera de software y se trata de una tcnica para dilucidad requerimientos y comportamientos esperados del sistema.
4.4.2 Grcos en 3D
La informacin resultante de los clculos brinda conjuntos (vectores) de datos para mltiples variables (presin, temperatura, composicin, densidad, etc) Tomando tres vectores de datos en vez de dos, pueden gracarse diagramas 3D, (por ejemplo P-T-composicin) sin necesidad de alterar el backend de manera alguna. Esta funcionalidad debe soportarse en la nueva implementacin.
4.4.3 Superposicin automtica

Dada la visualizacin 3D, es comn que el investigador desee superponer diagramas de lnea de contorno (isobaras, isopletas, etc.) sobre el diagrama de fase global del mismo caso para ver su disposicin tridimensional. Este comportamiento debe ser automtico. Es decir, cualquiera sea el diagrama solicitado, debe generar un diagrama 2D independiente y trazar estas mismas curvas sobre un diagrama 3D comn para todo el caso.
4.4.4 Superposicin manual

El usuario puede necesitar superponer visualmente diagramas 2D, ya sean estos del mismo caso (por ejemplo, un diagrama P-T global con una isopleta) o bien de distintos casos (por ejemplo, diagramas PT correspondientes a distintas mezclas)
4.4.5 Validacin de orden del sistema

En la denicin de un sistema binario el usuario puede elegir cualesquiera dos compuestos de la base de datos, sin importar el orden. A los nes del clculo, es necesario disponer el compuesto ms liviano, en trminos termodinmicos, para que el resultado sea vlido. La determinacin de esta condicin debe validarse, y en caso necesario, invertir el orden de compuestos dado por el usuario. El sistema es vlido si se cumple que la funcin peso 5 del compuesto 1 es menor a la del compuesto 2, es decir:
5
La validez de esta funcin fue comprobada de manera emprica por Cismondi.
24
Tc14 T 14 1 < c2 Pc1 Pc 2
4.5 Casos de uso

Se describen a continuacin los casos de uso ms relevantes del sistema. Basado en lo expuesto en la seccin Modelado conceptual vs. UML no se realiza una enumeracin minuciosa de las condiciones de contexto, ujos alternativos, etc. y en cambio se describen en un formato asociado a historias de usuario 6
4.5.1 Denir caso de estudio

El usuario dene un caso (Figura 4.5) mediante la conjuncin de la denicin de un sistema qumico binario (dos compuestos), la denicin de un modelo de clculo (de las 5 disponibles) y el clculo o denicin de los parmetros.
Figura 4.5: Caso de uso: denicin de un caso de estudio en GPEC
4.5.2 Gracar diagramas

Una vez denido el sistema el usuario solicita la gracacin de los diagramas (Figura 4.6) para lo cual el sistema los calcula. Independientemente de la suite de diagramas solicitados por el usuario el clculo de los diagramas globales es precedente.
6
Ver http://es.wikipedia.org/wiki/Historias_de_usuario
4.5. Casos de uso
25
Figura 4.6: Caso de uso: gracacin de diagramas
4.5.3 Denir sistema

En este caso de uso se produce la interaccin del usuario con la base de datos. Como se observa en el diagrama de la gura 4.7, el usuario puede elegir compuestos previamente denidos para la conformacin del sistema binario o bien crear nuevos compuestos.
Figura 4.7: Caso de uso: denicin del sistema binario
4.5.4 Clculo Global

El backend se modela como un actor lgico (subsistema) que interactua con el software desarrollado realizando el clculo de los distinto diagramas. Se observa en la gura 4.8.
4.5.5 Clculo de parmetros

Denidas las constantes de los compuestos (obtenidas de la denicin del sistema) se calculan los parmetros del modelo elegido a travs del backend o bien se ajustan las constantes de los 26 Captulo 4. Ingeniera de requerimientos
Figura 4.8: Caso de uso: gracacin de diagramas compuestos en funcin de los parmetros denidos manualmente por el usuario. Se representa en el diagrama de la gura 4.9.
Figura 4.9: Caso de uso: Clculo de parmetros
4.5. Casos de uso
27
28
CAPTULO 5
Metodologa
Este capitulo detalla el marco conceptual y la metodologa de desarrollo adoptada. Esta decisin ha sido rectora de subsecuentes decisiones de diseo y, de cierta manera, de la tecnologa adoptada para la implementacin.
5.1 Metodologas giles

Este proyecto integrador ha sido guiado por un conjunto de preceptos comunes a las metodologas giles de desarrollo de software. Sin necesariamente ajustarse a ninguna en particular, se comparte la escala de valoracin hecha en Agile Maniesto [AG-MANIF] que declara: Estamos descubriendo formas mejores de desarrollar software tanto por nuestra propia experiencia como ayudando a terceros. A travs de este trabajo hemos aprendido a valorar: Individuos e interacciones sobre procesos y herramientas Software funcionando sobre documentacin extensiva Colaboracin con el cliente sobre negociacin contractual Respuesta ante el cambio sobre seguimiento (estricto) de un plan Esto es, aunque valoramos los elementos de la derecha, valoramos ms los de la izquierda. Las implementaciones del marco conceptual propuesto por el Maniesto de desarrollo gil (como eXtremme Programming o Scrum) estn estructuralmente concebidas para el trabajo de un equipo de desarrollo abocado al mismo proyecto. Como el desarrollo del software estuvo a cargo de una sola persona (con la colaboracin y revisin de los directores) no se ajust a un mtodo estrictamente denido para un equipo como los mencionados. Sin embargo, muchas ideas propuestas por estos mtodos han sido aplicadas, concibiendo un desarrollo evolutivo con nfasis en la adaptabilidad de los requerimientos. Algunas de las tcnicas y procesos giles involucrados en este desarrollo han sido la utilizacin de un lenguaje de muy alto nivel (ver Tecnologas adoptadas ), la implementacin de pruebas 29
automatizadas, la utilizacin de bibliotecas probas para la implementacin de aspectos especcos de la solucin, entre otras.
5.2 Desarrollo evolutivo adaptado

Segn [Sommerville2004], el desarrollo evolutivo se basa en la idea de una implementacin inicial, exponindola a los comentarios del comitente o los usuarios, y renndola a travs de diferentes versiones preliminares (versiones beta) hasta obtener una versin que satisfaga el conjunto de requerimientos planteado.
Figura 5.1: Esquema conceptual del desarrollo evolutivo
Las actividades de especicacin, desarrollo y validacin se entrelazan en vez de separarse, con una rpida y constante retroalimentacin entre estas. Existen dos grandes tipos de desarrollos evolutivos: 1. Desarrollo exploratorio donde el objetivo del proceso es trabajar con el cliente para explorar y precisar los requerimientos y obtener un sistema nal. Se comienza con las partes del sistema que ms cabalmente se comprenden y se evoluciona agregando nuevos atributos precisados por el comitente, la comunidad de usuarios o el propio equipo de desarrollo. 2. Prototipos desechables donde el objetivo del proceso es comprender mejor los requerimientos. Una vez evacuadas todas las incertidumbres, los prototipos se desechan y se disea e implementa el sistema nal desde el principio.
5.3 Modelado conceptual vs. UML

Basado en los postulados de [AG-MANIF] durante el desarrollo se ha hecho hincapi en un modelado y documentacin orientados a favorecer la comunicacin por sobre el apego estricto y exhaustivo al lenguaje UML y sus tcnicas asociadas, intentando que el resultado sea til para el comitente, evaluadores y futuros desarrolladores del proyecto.
30
Captulo 5. Metodologa
5.3.1 Justicacin
Segn arma Terry Quatrani, evangelizadora de las metodologas giles en IBM, en [Quatrani2010] : Aunque sigas un proceso gil, estars realizando cierto grado de modelado slo que no lo realizars tanto como si utilizaras un proceso tradicional. La falta de formalidad en el modelado gil no signica que no ests modelando, sino que te pones el foco en los benecios de este sin las desventajas y confusiones de documentos extraos y burocrticos. Por su parte, Robert Martin sostiene en [Martin2006] que el modelado basado en UML en el desarrollo gil es til como instrumento de comunicacin, pero su detalle no aporta valor signicativo: No gastes mucho tiempo en esta tarea, no necesitas tanto detalle. Los modelos y los planos son necesarios en la arquitectura y la construccin civil porque es caro construir una casa para demostrar que su diseo funciona. El software no es as puedes validar tu idea con slo codicarla, en igual tiempo que el que insume hacer un modelo UML que nada prueba por s mismo. Aun ms escptico, Alans Stevens, reconocido ingeniero en software 1 y conferencista, opina en [Stevens2006] : No uso UML y noto que ninguno de mis colegas lo usa. Tengo sensaciones mezcladas acerca de su necesidad. Parece perfectamente razonable que debamos acordar como industria un conjunto de smbolos comunes para representar la programacin orientada a objetos, pero UML tiene la tpica apariencia de diseado por un comit. (...) El aspecto ms crtico en un diseo inicial, en mi experiencia, es la interfaz entre la UI (interfaz de usuario) y el modelo de objetos. Lamentablemente UML no aborda este problema y en cambio parece obsesionado por las minucias en una parodia de distraccin acadmica.
Premio M OST VALUABLE P ROFESSIONAL (MVP) de Microsoft por sus aportes a la comunidad de usuarios del lenguaje C#. http://bit.ly/as_mvp
5.3. Modelado conceptual vs. UML
31
32
Captulo 5. Metodologa
CAPTULO 6
Tecnologas adoptadas
Se expondr a continuacin las justicacin de adopcin de las herramientas y tecnologas utilizadas acompaada de una introduccin a las caractersticas y conceptos claves de cada una. Ver Tambin: En el captulo Implementacin se ahonda en algunos aspectos para explicar cuestiones particulares.
6.1 Lenguaje de programacin

6.1.1 Adopcin de Python
La eleccin del lenguaje de desarrollo fue clave y previa a muchos otras decisiones a lo largo de la vida del proyecto. Dadas las caractersticas y requerimientos de la aplicacin a desarrollar se requera un lenguaje que satisfaga las siguientes condiciones: Lenguaje de muy alto nivel que permita rpido prototipado Multiplataforma Orientacin a objetos completa y exible Posibilidad de crear interfaz de usuario compleja Licencia libre no restrictiva Integracin con bibliotecas de gracacin 2D y 3D Documentacin accesible y clara En el anlisis realizado, Java y Python (entre otros) satifacen esas condiciones pero se opt por el segundo dadas las siguientes razones:
33
Se contaba con un dominio ms profundo y mayor experiencia, dado trabajos acadmicos y laborales previos realizados con este lenguaje Es un lenguaje sintcticamente ms sencillo Las opciones de gracacin 2D y 3D se consideraron ms logradas. Para una resultado equivalente deban usarse sendas bibliotecas en Java, con APIs distintas. Las interfaces de escritorio en plataformas Linux de Java no son nativas La posibilidad a futuro de mejorar la integracin con el backend (Fortran) es limitada en Java, y en cambio Python cuenta con herramientas como F2Py (http://www.scipy.org/F2py)
6.1.2 Caractersticas de Python

Python (http://python.org) es un avanzado lenguaje de programacin de alto nivel, interpretado, multiparadigma y multiplataforma. interpretado Un lenguaje interpretado es un lenguaje de programacin que est diseado para ser ejecutado por medio de un intrprete (o mquina virtual), en contraste con los lenguajes compilados. En general, el proceso consiste en traduccin del cdigo fuente a un bytecode que el interprete traduce a su vez, en tiempo de ejecucin y cuando lo necesita, a cdigo mquina. multiparadigma Python soporta mltiples paradigmas de programacin. En vez de exigirle al usuario (o forzar el problema para) que se ajuste a un estilo de programacin, el lenguaje permite diversos estilos o una mezcla de ellos. Puede usarse con un paradigma estructurado e imperativo (como C o Pascal), como orientado a objetos (como Java o C++). Adems soporta caractersticas de programacin funcional, orientada a aspectos (AOP), y de metaprogramacin. multiplataforma Existen intrpretes de Python para distintas arquitecturas (x86, i64, powerpc, etc.) y sistemas operativos (Windows, Linux, OS/x, etc.) manteniendo el mismo cdigo y funcionalidades de alto nivel. Esto permite una altsima portabilidad del software, de manera que un mismo programa puede ser ejecutado en diferentes plataformas. Un sencillo programa Hola Mundo 1 en Python se ve as:
print "Hola Mundo!"
Adems, la mayora de sus implementaciones 2 , permiten ejecutar cdigo en modo interactivo al estilo Matlab u Octave, de manera que las expresiones pueden ser introducidas una a una y ver el resultado de su evaluacin inmediatamente:
1 Un programa Hola Mundo! es el que imprime el texto Hola Mundo! en un dispositivo de visualizacin (generalmente una pantalla de monitor). Se suele usar como introduccin al estudio de un lenguaje de programacin, siendo un primer ejercicio tpico. 2 Python es un lenguaje estandarizado que tiene distintas implementaciones. La original y ms utilizada es Cpython, implementada en C, pero existen implementaciones en Java (http://jython.org), .NET (http://www.ironpython.net/) y en Python mismo (http://codespeak.net/pypy)
34
Captulo 6. Tecnologas adoptadas
>>> 2 >>> >>> [0,
1+1 a = range(10) print a 1, 2, 3, 4, 5, 6, 7, 8, 9]
Esto resulta til tanto para los principiantes que se estn familiarizando con el lenguaje como para los programadores avanzados: se pueden probar porciones de cdigo en el modo interactivo antes de integrarlo como parte de un programa. Por diseo 3 , Python tiene sintaxis muy clara que facilita la legibilidad del cdigo. Esta caracterstica es la razn por la que Guido van Rossum, su creador, lo compara con pseudocdigo ejecutable 4 . El siguiente programa aplica conceptos de programacin orientada a objetos como herencia y polimorsmo. La implementacin en Python es la siguiente:
class Animal: """Superclase que define un constructor comn y un mtodo abstracto""" def __init__(self, nombre): self.nombre = nombre def hablar(self): raise NotImplementedError(u"La subclase debe \ implementar el mtodo") class Gato(Animal): def hablar(self): return Miau! class Perro(Animal): def hablar(self): return Guau, guau! #instanciacin de 3 objetos dentro de una lista animales = [Gato(Michi), Gato(Felix), Perro(Firulai)] for animal in animales: print animal.nombre + : + animal.hablar() #Imprime lo siguiente: # #Michi: Miau! #Felix: Miau! #Firulai: Guau, guau!
La hiptesis en la que se bas su creador es que el cdigo fuente suele leerse muchas ms veces de las que se escribe, ya sea por el mismo autor tiempo despues de haberlo escrito, o por otros programadores. 4 Syntactically, Python code looks like executable pseudo code., [GvR1998]
3
6.1. Lenguaje de programacin
35
Puede ver el artculo [WIKIPEDIA1] para una comparacin (en particular la extensin y legibilidad) de cdigo equivalente en otros lenguajes de programacin. Nota: Dar una introduccin completa a las capacidades de Python como lenguaje de programacin quedan fuera de los alcances de este trabajo. Para ampliar los conceptos aqu vertidos puede ver [TUT-PSF] y [MP2001]. En Python el tipado de datos es dinmico (al igual que la asignacin de memoria), es decir que el tipo de dato (entero, cadena, punto otante u otros tipos de ms alto nivel como listas o diccionarios) se determina automticamente al momento de la asignacin de la variable, a diferencia de los lenguajes de tipado esttico (como Java o C) que exigen la declaracin de todas las varibles con sus tipos antes de ser utilizadas. Sin embargo, el tipado es fuerte, ya que una vez que la variable adquiere un tipo (o sea, ha sido asignada), queda determinado su tratamiento. Por ejemplo la operacin + entre cadenas de texto retorna la concatenacin de las cadenas, mientras que entre tipos numricos retorna la suma. Intentar operar con + entre un nmero y una cadena dar un error sino se convierte una de las dos variables al otro tipo de manera explcita. El lenguaje incluye una robusta biblioteca estndar (se dice habitualmente que Python tiene con las bateras includas) con acceso a funcionalidades de todo tipo como protocolos de internet, funciones matemticas, manejo de hilos y multiprocesos, pruebas unitarias, manipulacin de XML y abstraccin de llamadas al sistemas operativo subyacente, entre muchas otras. Adems de la biblioteca incorporada, puede utilizar diversas bibliotecas externas, por ejemplo para desarrollar interfaces grcas de usuario (GUI ) (ver WxPython), y a la vez es extensible en C o C++. Esta facilidad de integracin permite que frecuentemente sea utilizado como lenguaje pegamento (ver [GvR1998] ) para interconectar cdigo que por razones de diseo, de performance o histricas estn desarrolladas en otro lenguaje de ms bajo nivel, permitiendo aprovechar las ventajas de Python. Python ha ganado popularidad no slo entre programadores acionados sino en el mercado altamente competitivo de la industria del software. Como plantea Shannon Behrens en el prlogo de [ZIADE2008]: Hubo un tiempo en el que las compaas me llamaban loco cuando insista en usar Python. En estos das, simplemente no hay sucientes programadores Python para todas. Grandes empresas como Google, YouTube, VMware y DreamWorks estn en una lucha constante para contratar todo buen talento Python que puedan encontrar. 5
6.1.3 Python en el software cientco

Como se arma en [JH-FP] en la seccin Who is using Python?, el uso de Python en la computacin cientca es tan amplio como el campo mismo. Los autores destacan muchos usos en distintas universidades y centros de investigacin del mundo:
5
Traduccin del ingls propia.
36
El Jet Propulsion Laboratory (JPL) de la NASA (National Aeronautics and Space Administration, EE.UU.) usa Python como interfaz a bibliotecas Fortran y C++ que conforman una suite de herramientas de visualizacin de trayectorias. El Space Telescope Science Institute (STScI) lo usa en muchos aspectos de su pipeline, planicando la adquisicin de datos del telescopio Hubble, administrando volumenes de informacin y analizando imgenes atronmicas. La National Oceanic Atmospheric Administration (NOAA) usa Python para el anlisis sintctico de archivos, el prototipo de algoritmos computacionales, la codicacin de interfaces de usuario de escritorio y web y el desarrollo de modelos. La Enthought Corporation lo usa para adaptar a las necesidades de sus clientes aplicaciones para la exploracin de petroleo. Ver Tambin: Muchos otros casos de xito son detallados en el texto mencionado, en los dos volumenes de Python Success Stories de la editorial OReillys 6 y en http://python.org/about/success/
6.2 NumPy
Los tipos de datos incorporados con Python nativamente para contener otros tipos de datos u objetos (en particular listas y tuplas), son muy ecientes pero estn diseados para ser multipropsito. Estos contenedores pueden albergar cualquier tipo de objeto (incluso una mezcla de ellos) y las listas, en particular, pueden mutar (agregar, modicar o borrar elementos) dinmicamente. Es decir que si bien pueden usarse listas o tuplas como un arreglo de datos, no estn especialmente concebidas para tal n. Nota: Los siguientes prrafos descriptivos han sido tomados, a modo de parfrasis y traducido por el autor, del capitulo What is NumPy? de [NumPy-UG]. NumPy (http://numpy.org) es una biblioteca que extiende Python para complementar este aspecto, proveyendo un tipo de objeto vector multidimensional (ndarray) y varios objetos derivados (como vectores enmascarados o matrices), adems de rutinas optimizadas para la operacin sobre estos vectores, incluyendo operaciones matemticas y lgicas, manipulacin de dimensiones, lgebra lineal, operaciones estadsticas bsicas, simulacin aleatoria, etc. Considere el cdigo siguiente que dado dos secuencias unidimensionales a y b de igual longitud y con todos sus elementos numricos, multiplica elemento por elemento y dispone el resultado en una nueva lista c:
Python Success Stories: 8 True Tales of Flexibility, Speed, and Improved Productivity (2002) y Python Success Stories Volume II: 12 More True Tales (2005), OReilly Associates
6
6.2. NumPy
37
c = [] for i in range(len(a)): c.append(a[i]*b[i])
El resultado ser correcto, pero considerando que las secuencias a y b pueden tener millones de elementos, se pagar el precio de una iteracin ineciente. Esta operacin, siendo a y b objetos ndarray de NumPy, resultara en:
c = a * b
Dicho cdigo funcionara siempre que a y b tengan las mismas dimensiones, independientemente que sean uni o multidimensionales. El ejemplo ilustra dos caractersticas de NumPy que son gran parte de las bases de su poder: vectorizacin y broadcasting La vectorizacin describe la ausencia de iteraciones explcitas e indizacin (que toman lugar, por supuesto, detrs de escena, en un optimizado y precompilado cdigo C). La vectorizacin tiene muchas ventajas: El cdigo vectorizado es ms conciso y fcil de leer. Menos lneas de cdigo habitualmente implican menos errores. El cdigo se parece ms a la notacin matemtica estndar (por lo que es ms fcil, por lo general, corregir cdigo asociado a construcciones matemticas La vectorizacin redunda en un cdigo ms pythnico 7 El broadcasting o difusin es el trmino que describe el comportamiento elemento por elemento de las operaciones. En general, en NumPy todas las operaciones adoptan por defecto un comportamiento de este tipo (no slo las operaciones aritmticas sino las lgicas, las funcionales y las de nivel de bits). Por defecto Numpy dene el tipo de dato del array de elementos como el mnimo capaz de contener la informacin brindada. Se incluyen tipos otantes de hasta 128 bits de precisin (16 bytes) 8 .
6.2.1 Alternativa analizada

Estrictamente, existe un mdulo que da soporte a arreglos (ver Array (http://docs.python.org/library/array.html)) en la biblioteca estndar de Python. Sin embargo, las funcionalidades provistas no son comparables a las de Numpy y fue por ello descartado.
El cdigo que sigue los principios de legibilidad y transparencia propuestos por Python se dice que es pythonico. Contrariamente, el cdigo opaco u ofuscado es bautizado como no pythonico. Ver [PEP8] y [PEP20]. 8 Los tipos oat64 y complex128 existen en todas las plataformas. En algunas, la precisin es extendida a 96 y 128 bits por nmero (el doble para complejos) si la arquitectura lo permite.
7
38
6.3 Matplotlib
Matplotlib (http://matplotlib.sourceforge.net/) es una biblioteca para Python, liberada como software libre, que permite la generacin de diferentes tipos de grcos en 2D y 3D con calidad de publicacin. Se pueden generar grcos cartesianos, polares, de barras, histogramas, de supercie, etc.
Figura 6.1: Ejemplos de grcos logrados con Matplotlib
Matplotlib puede usarse de una manera pythnica y orientada a objetos. Est principalmente escrito en Python, aunque se basa fuertemente en NumPy y otras extensiones para proveer buena performance incluso con arreglos grandes. Si bien fueron estudiadas otras bibliotecas libres con prestaciones similares como Chaco o GNUplot 9 , se opt por Matplotlib dadas las siguientes caractersticas: Cuenta con una extensa y clara documentacin (ver [MPLDOC]) Es orientado a objetos: se puede heredar, extender y sobrecargar cada tipo de objeto que dene La calidad de los grcos es excepcional, permitiendo la exportacin a muchos formatos grcos, incluyendo PS (PostScript) y SVG (Scalable Vector Graphic) Es empotrable dentro de las bibliotecas para GUI ms utilizadas permitiendo realizar aplicaciones de escritorio manteniendose en un alto nivel de abstraccin. Incorpora muchos paquetes que extienden las posibilidades: el muy logrado paquete para gracacin 3D, gracacin sobre mapas geogrcos, utilidades para la interaccin con Microsoft Excel, etc. Matplotlib incluye una API que tiene su origen en la emulacin de los comandos grcos de Matlab, denominada PyPlot, especialmente orientada a su uso interactivo. El siguiente cdigo es un ejemplo extrado de [ST2009]
>>> import matplotlib.pyplot as plt >>> import numpy as np >>> x = np.arange(0.0, 6.0, 0.01)
Chaco (http://code.enthought.com/chaco/) y GNUplot-Py (http://gnuplot-py.sourceforge.net/) son las ms notables alternativas.
9
6.3. Matplotlib
39
>>> plt.plot(x, x**2) >>> plt.show()
El resultado se observa en la gura 6.2.
Figura 6.2: Grco generado interactivamente
6.4 WxPython
wxWidgets (http://www.wxwindows.org/) es una biblioteca en C++ que permite desarrollar interfaces grcas para aplicaciones multiplataforma que corren en Microsoft Windows, OS X, GNU/Linux o UNIX de 32 o 64 bits. wxPython (http://www.wxpython.org/) es un wrapper de la biblioteca wxWidgets para el lenguaje de programacin Python. Junto a Python permite el desarrollo rpido de aplicaciones grcas de escritorio multiplataforma. Una de las caractersticas sobresalientes de wxWidgets es su uso nativo de las APIs grcas de cada entorno, brindando una apariencia y experiencia de uso nativa para cada ambiente. Esto signica la misma aplicacin, sin modicaciones (al menos signicativas), adopta las caractersticas grcas denidas por el usuario en el entorno de escritorio. En concreto: se ve como una aplicacin Windows si se corre en Windows, como una aplicacin GNOME si se corre sobre el gestor de escritorio GNOME en Linux, y como una aplicacin OS/X en platafomas Mac:
40
Figura 6.3: El mismo programa wxPython ejecutado en Windows, Linux y Mac La gua [NR-RD2006] escrita por dos de los desarrolladores de la biblioteca es un material de referencia obligado para el desarrollo con wxPython. All se exponen como caractersticas relevantes la orientacin a objetos y la orientacin a eventos. Atencin: En la bibliografa de wxPython se denomina window a cualquier elemento grco que ocupa espacio visual y puede ser contenido por otro. Lo que comunmente se denomina window (ventana) en otros escenarios, en wxPython es un frame, es decir, una ventana de programa. Se expondrn estos conceptos con un ejemplo:
import wx class MyFrame(wx.Frame): def __init__(self): wx.Frame.__init__(self, None, -1, "Ventana", size=(300, 300)) panel = wx.Panel(self, -1) wx.StaticText(panel, -1, "Pos:", pos=(10, 12)) self.posCtrl = wx.TextCtrl(panel, -1, "", pos=(40, 10)) panel.Bind(wx.EVT_MOTION, self.OnMove) def OnMove(self, event): pos = event.GetPosition() self.posCtrl.SetValue(" %s, %s" % (pos.x, pos.y)) if __name__ == __main__: app = wx.PySimpleApp()
6.4. WxPython
41
frame = MyFrame() frame.Show(True) app.MainLoop()
La subclase MyFrame hereda de la clase wx.Frame y extiende su constructor incluyendo un objeto Panel (elemento contenedor de otros objetos grcos), una lnea de texto esttica y una caja de texto denominada self.posCtrl. Adems se realiza un binding, es decir, la asociacin de un evento identicable a una accin, un mtodo o funcin que indica como responde el programa ante el acaecimiento del evento. En este caso se asocia el evento wx.EVT_MOTION en el objeto panel (que ocurre cuando se mueve el puntero sobre el objeto) al mtodo OnMove. Como ejemplica la gura 6.4, cada vez que se mueve el puntero sobre el panel, la caja de texto ser actualizada con las coordenadas donde este se encuentra.
Figura 6.4: Captura del ejemplo de marras
Como caracterstica avanzada, wxPython incluye el mdulo AUI (A DVANCED U SER I NTER FACE ) que permite el desarrollo de interfaces de usuario orientadas a la usabilidad y de alta calidad, abstrayendo y encapsulando el control de aspectos comunes. En particular, este mdulo permite la gestin de subframes, de manera que los subcomponentes o subventanas pueden congurarse mediante operaciones comunes como abrir, cerrar u ocultar, y ser guardadas como perspectivas que el usuario puede recuperar en posteriores sesiones de trabajo.
6.4.1 Alternativas analizadas

Python soporta un gran nmero toolkits para desarrollo de interfaces de usuario. Las estudiadas como alternativa fueron: GTK a travs de PyGTK QT a travs de PyQT o PySide 42 Captulo 6. Tecnologas adoptadas
Tcl/Tk a travs del paquete estndar Tkinter Si bien Tkinter contaba con la ventaja de no requerir software adicional a Python para su utilizacin, se opt por wxPython dada la experiencia previa y la apariencia nativa en cada sistema operativo.
6.5 El patrn Publish/Subscribe

Un patrn de diseo (tambin catalogado como patrn de mensajera) de recurrente aplicacin en GPEC ha sido Publish/Subscribe, frencuentemente abreviado Pubsub. Se trata de una arquitectura de paso de mensajes desacoplada (y en algunas implementaciones distribuda) donde existen remitentes (o publicadores) que envan mensajes ante el acaecimiento de un suceso especco (por ejemplo, un evento originado por el usuario como el click sobre un botn) sin conocimiento alguno sobre qu sucede despues con el mensaje. Anlogamente existen receptores (o suscriptores) que en cuya inicializacin se dene a qu tipo de mensajes se suscribirn (el tipo se dene en funcin del asunto o topic) y qu accin (un mtodo o funcin) debe ejecutarse cuando un mensaje de tal tipo arribe.
Figura 6.5: Diagrama conceptual de la arquitectura Pub/Sub Como se describe en [vdLaar2002] Pubsub facilita el desacople de componentes (callables, mdulos, paquetes) dentro de una aplicacin. Los conceptos involucrados son: Permitir que partes de una aplicacin enve mensajes al resto de la aplicacin sin tener que conocer: si el mensaje ser manejado y usufructuado: puede suceder que el mensaje se ignore completamente o que sea manejado en muchas partes diferentes de la aplicacin cmo ser manejado el mensaje: al publicador no le importa qu se har con el mensaje y su contenido;
6.5. El patrn Publish/Subscribe
43
Software para la gracacin de diagramas termodinmicos tampoco hay control del orden en que un mensaje dado se enviar al resto de la aplicacin (comportamiento no determinstico). Permitiendo que partes de una aplicacin reciban y manejen mensajes desde el resto de la aplicacin sin tener que conocer quin envi el mensaje. Un receptor (listerner) es una parte de la aplicacin que quiere recibir mensajes. Un receptor se suscribe a uno o ms tpicos. Un emisor (sender) es cualquier parte de la aplicacin que enva (deposita en el intermediario) un mensaje con un tpico dado, y opcionalmente, cualquier informacin adjunta. Este intermediario (a veces conocido como broker, o directamente pubsub) entrega este mensaje a todos los receptores suscriptos.
6.5.1 Ventajas
Acoplamiento dbil: la topologa de Pubsub, basada en la intermediacin y el desconocimiento de identidades y comportamientos de los objetos que interactuan permite un desacople de los componentes de la aplicacin. Esto signica que las distintas partes de la aplicacin son independientes entre s, de modo que pueden facilmente desactivarse componentes no crticos sin afectar al conjunto de la aplicacin. Esta estrategia es til para realizar pruebas de seguridad. Funcionalidad congurable : Dado que un emisor no tiene necesidad de conocer la existencia de un receptor, es fcil disear una arquitectura basada en plugins que permite mantener un ncleo y agregar funcionalidades extra con posterioridad (incluso desarrolladas por terceros). Esto trae aparejada la posibilidad de adaptar, mediante extensiones que se activan o no, las caractersticas del software en funcin de las necesidades del usuario. Escalabilidad: En las implementaciones distribuidas de demanda moderada (donde los mensajes se transmiten entre mltiples procesos o, incluso, equipos), PubSub provee una arquitectura mucho ms simple y autogestionada que la tpica topologa cliente/servidor para tareas de procesamiento paralelo o Sin embargo, la eciencia no suele ser proporcional en sistemas de alta demanda computacional.
6.5.2 Pubsub en Python

En GPEC se ha utilizado el paquete Python Pubsub (http://pubsub.sourceforge.net/) de Oliver Schoenborn, en su versin 1 10 . Esta implementacin es muy sencilla y se basa en la existencia de un objeto nico (Ver singleton), pub, que controla el envo y las suscripcin a los mensajes. Se describe en el siguiente cdigo:
from pubsub import pub # declaracin de la funcin "destino"
def destino(arg1, arg2=None):

En 2010 el autor de Python PySub reescribi completamente la API , agregando una orientacin a objetos del paso de mensajes ms poderosa, a la que denomin version 3.
10
44
print Mensaje con arg1=" %s" y arg2=" %s" % (arg1, arg2) # declaracin de suscripcin pub.subscribe(destino, asuntoParticular) # funcin que enva un mensaje def hacer_algo_y_avisar(): print Se enviar un mensaje pub.sendMessage(asuntoParticular, arg1=123, arg2=dict(a=abc, b=def)) if __name__ == __main__: hacer_algo_y_avisar()
Cuyo diagrama de secuencia se muestra en 6.6.
Figura 6.6: Diagrama de secuencia para una interaccin sencilla entre emisor y receptor via Pub/Sub
6.6 Gestin de proyecto

En cualquier proyecto de software no trivial, sistematizar todos los aspectos del desarrollo es una necesidad ineludible. Esto incluye, por supuesto, la evolucin del cdigo, pero tambin su documentacin, el reporte, seguimiento y solucin de los errores detectados, la planicacin de las etapas de desarrollo, la estimacin de la carga de trabajo, etc. La gestin de proyecto es uno de los aspectos esenciales de la ingeniera de software. Como se explaya en [GR-STE2005], se necesita ms que una buena idea y equipo de programadores 6.6. Gestin de proyecto 45
talentosos para tener xito con un proyecto de software. Exiten tcnicas y herramientas para minimizar la ocurrencia de errores, la prdida de informacin o tiempo. Del vasto conjunto de herramientas, se detallan aqu las utilizadas para el desarrollo de este trabajo.
6.7 Control de versiones

Un VCS (Sistema de Control de Versiones) es un software capaz de llevar registro de la evolucin incremental de cualquier conjunto de archivos, permitiendo recuperar estados anteriores (de una fecha en particular, por ejemplo) de una manera eciente y automatizada. Cada vez que se detecta un cambio, el software de control almacena slo la informacin necesaria (en particular la diferencia respecto a la versin anterior de cada archivo) en vez de guardar todo el archivo completo. En particular,tiene mucha utilidad para archivos de texto, como el cdigo fuente de un software. El VCS utilizado para este proyecto fue Subversion (http://subversion.apache.org) (frecuentemente abreviado SVN). Subversion es un VCS centralizado, es decir, requiere un servidor central (repositorio), generalmente accesible va internet, que almacena todas las versiones (revisiones) de cada archivo. El usuario/desarrollador realiza un commit para enviar sus modicaciones locales al repositorio, y un update para actualizar la versin local (copia de trabajo) con la ltima versin (o la indicada explcitamente) del repositorio. Con cada commit, el sistema solicita la inclusin de un mensaje descriptivo de la modicacin realizada, de manera de poder realizar un seguimiento y detectar un estado en particular si, por alguna razn, es necesario recuperar. Como servidor svn se utiliz el servicio de Google Code, que brinda un repositorio y otras herramientas de gestin de proyecto de manera gratuita, para desarrollos de software libre / open source. El proyecto se encuentra en la direccin http://code.google.com/p/gpec2010 .
Figura 6.7: Portada del proyecto en Google Code.
46
6.8 Seguimiento de errores y propuestas

El mismo servicio que provee el repositorio svn gratuito, incluye un sistema de gestin de errores (bug tracker o, ms generalmente, issue tracker), del cual se ha hecho uso exhaustivo. Estos sistemas permiten la sistematizacin del ciclo de vida de un error, solicitud de funcionalidad o mejora. A travs de una interfaz web (caracterstica comn a casi todos los sistemas de este tipo), el propio equipo de desarrollo o usuarios particulares pueden reportar un incidente (issue), con un mensaje breve y descriptivo que permita reproducir el error reportado, o bien fundamentando la necesidad de una mejora o nueva funcionalidad. El issue es asociado a palabras clave que identican su estado (abierto, aceptado, rechazado, solucionado, etc), su gravedad o inters (bajo, normal, alto), etc. Por supuesto, cada una de estas palabras clave puede cambiar con el tiempo, adjuntando mensajes que indican las tareas realizadas en cada intervencin, hasta que el issue sea cerrado, ya sea por que se logr una solucin o se decidi descartarlo por alguna razn. La utilidad de este tipo de sistemas permite la descentralizacin del reporte de errores, permitiendo a la comunidad de usuarios participar de la mejora del software. Tambin permite llevar registro de errores o funcionalidades pendientes en cada momento del desarrollo, facilitando la planicacin de lanzamientos de nuevas versiones.
6.9 Documentacin
Gran parte del desarrollo de un software as como el de un proyecto integrador o tesis en general, cualquiera sea el tpico, es la documentacin. Contar con procedimientos y herramientas adecuadas para la realizacin de este trabajo es tan necesaria e importante como el lenguaje de programacin adoptado para la codicacin del software. A lo largo de todo el proyecto se fue documentando distintos aspectos del desarrollo, con distintos niveles de detalle. Se utilizaron las siguientes herramientas.
6.9.1 restructuredText
Este documento se ha escrito utilizando el lenguaje de marcado reStructuredText (http://docutils.sourceforge.net/docs/user/rst/) (RST O REST). RST permite aportar semntica a un documento de texto plano, de manera equivalente a LaTeX pero mucho ms sencilla, conservando legibilidad en formato fuente. A travs de diversas herramientas se puede convertir rst a distintos formatos, como html, pdf o cdigo LaTeX. Como ejemplo de la sintxis de RST se muestra el inicio de esta misma seccin:
restructuredText ---------------Este documento se ha escrito utilizando el lenguaje de
6.8. Seguimiento de errores y propuestas
47
marcado reStructuredText <http://docutils.sourceforge.net/docs/user/rst/>_ (:abbr:rst o rest).
El uso de restructuredText permiti obtener un documento de apariencia profesional, con abundantes referencias cruzadas y gestin bibliogrca y terminolgica, con el plus de obtener una versin web desde el mismo contenido. Alternativas analizadas La alternativas analizadas fueron OpenOfce Writer que utiliza un esquema WYSIWYG (del ingls: lo que ves es lo que obtienes) al estilo Microsoft Word pero utilizando el formato estndar OpenDocument, y el lenguaje de marcado para textos cientcos LaTeX. El primero fue descartado por la dicultad de mantener homogeneidad de estilo y el pobre soporte a referencias cruzadas, y el segundo fue descartado por la complejidad de su sintxis.
6.9.2 Wiki
Una wiki es un sistema para la creacin de documentos hipertextuales de manera sencilla. Con el permiso adecuado, un documento (en general una pgina web) se convierte en editable, pudiendo modicar o ampliar el contenido, incluir imgenes u otro tipo de informacin, o generar enlaces a otros documentos. El servicio Google Code incopora una Wiki que se ha utilizado como cuaderno de notas para llevar cuenta de las minutas, links de inters, etc.
6.9.3 Sphinx
Sphinx (http://sphinx.pocoo.org) es una herramienta para la documentacin de software. Si bien permite la autodocumentacin (realizando introspeccin de las cadenas de documentacin y las entidades del cdigo fuente) est orientado a la creacin de documentacin escrita por humanos. Sphinx utiliza como formato de entrada el formato restructuredText (http://docutils.sourceforge.net/docs/user/rst/) y genera versiones en html (con motor de bsqueda y resaltado de cdigo incorporado) y PDF de alta calidad a travs de Latex.
48
CAPTULO 7
Arquitectura
En este capitulo se describe, de manera conceptual, el diseo arquitectnico de la aplicacin. La metodologa gil e iterativa adoptada no implica que no haya existido una profunda instancia de reexin en el diseo en la aplicacin, slo que esta no es estado basada ntegramente en una descripcin formal y exhaustiva como UML. Atencin: La adopcin de principios del desarrollo gil y el desarrollo evolutivo implica que no se ha utilizado un proceso de ingeniera de software ms frecuentemente enseado en el mbito acadmico. Esto es, el proceso de diseo e implementacin han sido mancomunados iterativamente en vez de separados estrictamente. De esta manera, muchos de los conceptos arquitectnicos estn intrnsecamente aqu expuestados estn relacionados intrsecamente con su implementacin.
7.1 Modelo conceptual

La siguiente infografa describe conceptualmente, de manera simplicada, el ujo de procesamiento de la informacin.
Figura 7.1: Diagrama conceptual del ujo de informacin entre las distintas capas El frontend, objeto de este trabajo, se compone de la interfaz de usuario, la gestin de base de 49
datos, los algoritmos de procesamiento de la informacin y la gracacin. API (Application Programming Interface) reere a la interfaz de comunicacin denida para la comunicacin entre ambas partes, que est basada en archivos de texto plano con un formato particular. El relevamiento de esta interfaz form parte del desarrollo, y se describe exhaustivamente en Especicacin de la interfaz de comunicacin. Una librera modularmente independiente, basada en ese relevamiento se program para dar soporte a la comunicacin. Se describe en Invocacin de ejecutables del backend. El backend reere al conjunto de programas desarrollados en Fortran que implementan los algoritmos de clculo. Estos programas leen uno o varios archivos de entrada y producen un archivo de salida con los vectores de nmeros reales resultantes de los clculos (la informacin a gracar) junto a otras informaciones relativas al contexto de clculo Los algoritmos de procesamiento del frontend analizan y extraen slo la informacin til, haciendo una conversin de texto a un tipo de dato numrico y con esa informacin se realizan los grcos correspondientes.
7.2 Componentes y capas de software

El diagrama de la gura 7.2 describe las capas y componentes de software involucrados en la aplicacin.
Figura 7.2: Arquitectura Frontend - Middleware - Backend Este diagrama brinda ms detalles sobre la vinculacin de los componentes y las capas de software. Por simplicidad, se ha obviado la descripcin de los componentes Matplotlib y Numpy, asumindolos tcitamente como parte de la aplicacin. 50 Captulo 7. Arquitectura
Los componentes de middleware de conexin a la base de datos sqlite3 (un wrapper sobre Sqlite) y el mdulo que permite la ejecucin de procesos hijos (o subprocesos) subproccess forman parte de las versiones 2.5 y 2.4 de Python respectivamente. Es decir, no son componentes de software que se requieran por separado. La llamada a los procesos del backend a travs de subproccess est intercedida por el emulador Wine en todas las plataformas diferentes a Windows. Esto se describe ampliamente en La dependencia con Wine. Un componente que se representa intrnsecamente vinculado al frontend es Pub/Sub. La explicacin de la importancia estructural de este componente se describe en Utilizacin de Publish/Suscribe en GPEC.
7.3 Capa de base de datos

La aplicacin no requiere una infraestructura de base de datos compleja. En particular, los datos almacenados son las constantes de compuestos qumicos. Se incluye una vasta base de datos termodinmicos para ms de 2000 compuestos, corroborados mediante DIPPR Project 801 <http://dippr.byu.edu/> 1 que incluye informacin como la frmula, el factor acntrico, el volumen, la temperatura y la presin crtica, etc. Esta informacin se comporta en modo slo lectura 2 a travs de la interfaz de usuario, pero se brinda tambin una categora editable para permitir compuestos denidos por el usuario que pueden ser agregados como una copia de un compuesto existente en DIPPR (que acepta, entonces, la modicacin o ajuste de sus valores) o bien como un nuevo compuesto denido desde datos experimentales.
7.3.1 Modelo Entidad-Relacin

El modelo Entidad-Relacin es un diagrama que describe la interrelacin de la informacin gestionada por la base de datos. Se muestra en la gura 7.3. Ver Tambin: Vea Implementacin de base de datos para la implementacin.
7.4 Diagrama de paquetes

El diagrama de paquetes de la gura 7.4, que forma parte de la suite denida por UML 2.0, muestra los paquetes y mdulos (unidades de cdigo fuente) y su rbol interdependencia.
DIPPR 801 es un producto comercial cuya licencia ronda los u$s3400 anuales. GPEC incluye en su base datos equivalentes a una porcin de la informacin que ese producto ofrece, sin depender de esta de manera alguna. No obstante, el autor considera este aspecto como suceptible a acarrear complicaciones legales y comerciales, que debern revisarse y solucioanrse a futuro. 2 Sqlite no permite denir tablas o registros de datos como slo lectura. Queda en potestad del desarrollador vedar la posilidad de modicacin como parte del proceso de validacin. Sin embargo, siempre es posible para un
1
7.3. Capa de base de datos
51
Figura 7.3: Representacin de las entidades con sus atributos y la relacin entre las mismas
Figura 7.4: Diagrama de paquetes
52
Captulo 7. Arquitectura
Este diagrama se realiz mediante un anlisis de ingeniera inversa utilizando la herramienta pyreverse (http://www.logilab.org/blogentry/6883)
7.5 Diagramas de clases

Se incluyen en las siguientes guras diagramas de clase de la aplicacin. Se insiste en que en el proceso de desarrollo no existi una especicacin de esta magnitud de detalle previa a la implementacin, pero se ofrecen al lector, generadas mediante el anlisis del cdigo, como orientacin sobre la estructura arquitectnica de la aplicacin.
7.5.1 Relacin y dependencia de los paneles

El diagrama de la gura 7.5 muestra la relacin y jerarqua de las clases que componen la interfaz de usuario.
Figura 7.5: Jerarqua de clases de la GUI La clase ShellPanel corresponde a una consola interactiva que se incluy en uno de los prototipos presentados, pero luego ha sido descartada en versiones actuales por no formar parte de los requerimientos especicados.
7.5.2 Relaciones del Panel de caso

El diagrama de clases de la gura 7.6 hace hincapi en la clase CasePanel y sus relaciones de composicin
usuario abrir y modicar la informacin manualmente a travs de un gestor que interprete el formato sqlite.
7.5. Diagramas de clases
53
Figura 7.6: CasePanel y su composicin
7.5.3 Clases vinculadas a la gracacin

El diagrama de la gura 7.7 describe las clases relacionadas con la gracacin. Muchas de estas forman parte de MatploLib.
Figura 7.7: Diagrama de clases relacionadas con la gracacin
7.5.4 Tipos de grcos

Los tipos de grcos 2D y 3D tiene un diseo jerarquico de clases como se muestra en la gura 7.8, donde las subclases reimplementan el mtodo que selecciona el subconjunto de datos que cada grco necesita. Los mtodos comunes son heredados de la superclase.
54
Figura 7.8: Diagrama de clases de los distintos tipos de diagramas soportados
7.5. Diagramas de clases
55
7.6 Preceptos adoptados en el diseo de UI

Como se ha mencionado, la usabilidad e intuitividad de la interfaz de usuario ha sido un requerimiento de especial atencin. Mucha bibliografa fue consultada al respecto, rescantando en particular muchos conceptos y consejos de Joel Spolsky en [Spolsky2001] 3 . Entre muchos, se destacan: Brindar contextos intuitivos y secuencias de operacin lgicas. Minimizar las opciones en simultneo. Cada opcin es una decisin que se le exige al usuario. Los usuarios no leen manuales (de hecho tampoco leen mensajes en pantalla si son largos) Convenciones por sobre conguraciones: limitar los parmetros requeridos Valerse de las costumbres del usuario: no reinventar la rueda Un software complejo con un acabado estudio de usabilidad es Mayavi (http://code.enthought.com/projects/mayavi/) , (Figura 7.9) que ha servido de inspiracin para el diseo de GPEC.
Figura 7.9: Interfaz de la aplicacin de visualizacin de diagramas VTK que sirvi como inspiracin para la interfaz de GPEC.
Una versin online gratuita de este libro se encuentra en http://www.joelonsoftware.com/uibook/fog0000000249.html
56
Algunas decisiones concernientes a la usabilidad han sido: El diseo acompaa al workow: primero se dene el sistema, opcionalmente se manipulan los clculos y por ltimo se graca. Slo el primero y el ltimo paso son obligatorios. La ubicacin de los botones principales est dispuesta en funcin del ujo de lectura de occidental (de izquierda a derecha y de arriba hacia abajo) de manera de resultar intuitiva la secuencia de acciones demandada al usuario Todos los botones tiene asociado un cono descriptivo Los componentes que muestran informacin no modicable se mantienen en modo slo lectura y visualmente se ven grisados. Un conjunto de parmetros (coecientes, reglas de combinacin) se ubican en un panel colapsable. Al expandirlo, el panel genera automtica una barra de desplazamiento vertical. El uso del smbolo + en la ubicacin dispuesta es una convencin popularizada por los navegadores web para abrir una nueva pestaa de trabajo. Dado el contexto resulta evidente que genera un nuevo caso. Los resultados del estudio e implementacin en materia de usabilidad se analizan en Pruebas de usabilidad.
7.6. Preceptos adoptados en el diseo de UI
57
58
CAPTULO 8
Implementacin
Este captulo recorre distintos aspectos de la implementacin de GPEC. Como se ha descripto en Metodologa, el proceso de implementacin y el de diseo han tenido a una evolucin conjunta e integrada a lo largo de la vida del proyecto. Si bien una visin de diseo se resume en el captulo Arquitectura, algunas decisiones y detalles se justican en este captulo.
8.1 Utilizacin de Publish/Suscribe en GPEC

En El patrn Publish/Subscribe (ver Marco Terico) se describi el patrn PubSub y la implementacin utilizada para diferentes aspectos del funcionamiento de GPEC. Aqu se describen en detalle sus usos en la aplicacin.
8.1.1 Panel de mensajes

Como se ha dicho, PubSub constituye el patrn principal y toda la orientacin a eventos de la biblioteca se basa en una comunicacin va esta biblioteca. El ejemplo cannico es el panel de log (registro de mensajes de usuario), donde se registra una crnica de eventos de inters para el usuario, denotados en su categora con un smbolo y la hora del suceso.
Figura 8.1: A travs de PubSub, cualquier parte del programa enva avisos que el panel (un receptor) mostrar al usuario.
59
En la incializacin del panel se realiza la subscripcin a los mensajes con tpico log, y asigna como accin el mtodo OnAppendLog():
class LogMessagesPanel(wx.Panel): def __init__(self, parent, id): wx.Panel.__init__(self, parent, id) self.list = wx.ListCtrl(self, -1, self.setupList() sizer = wx.BoxSizer() sizer.Add(self.list, 1, wx.EXPAND) self.SetSizerAndFit(sizer) pub.subscribe(self.OnAppendLog, log) style=
wx.LC_REPORT|wx.SUNKEN_BORDER
Ante la recepcin de un mensaje se produce la invocacin del mtodo adjuntando como parmetro un objeto mensaje (msg) en cuyo atributo data se almacena la informacin enviada por el remitente:
def OnAppendLog(self, msg): ico = self.icon_map[msg.data[0]] message = msg.data[1] index = self.list.InsertImageStringItem(sys.maxint, message, ico) self.list.SetStringItem(index, 1, time.strftime( %H: %M: %S)) self.list.EnsureVisible(index) #keep scroll at bottom if msg.data[0] == error: wx.Bell()
La informacin en msg.data es, por convencin de diseo, una tupla de la forma (asunto, mensaje de usuario). Los asuntos posibles estn asociados al icono que los representan: Asunto ok info warning error Smbolo Descripcin Accin existosa Informacin importante Advertencia Error
Como se observa en el cdigo, en caso de un mensaje del tipo error, adems de agregar el mensaje se ejecuta wx.Bell() que produce una alerta sonora. El remitente de mensajes de log se realiza desde mltiples puntos. Por ejemplo ante la carga de la aplicacin, cuando se dene un sistema, cuando se realiza un clculo (mediante la invocacin a un ejecutable del backend), etc. Por ejemplo, en el cdigo de ejecucin de la aplicacin, en aui.py se observa:
(...) main_frame.Show() pub.sendMessage(log, (ok, GPEC is ready. Define a system to begin) )
60
Captulo 8. Implementacin
app.MainLoop()
8.1.2 Solicitud de grcacin

Otro uso de PubSub se produce durante la solicitud de generacin de grcos. Se resume en el diagrama de secuencia de la gura 8.2. Esto signica que el panel de denicin de casos est independizado del panel contenedor de los grcos generados a traves de PubSub. El mencanismo invocacin del backend (desde donde se obtienen los datos a gracar) se ver ms adelante. El objeto SuitePlotsPanel es el panel de pestaas donde se muestran los grcos de todos los casos de un proyecto. Cada una de estas pestaas contiene un objeto PlotPanel que es el que soporta la integracin con Matplotlib y contiene el diagrama en s. Esta integracin se ver en Integracin Matplotlib-WxPython .
8.1.3 Exposicin de archivos de datos

Cada invocacin a un ejecutable del backend dependen de una entrada y produce una salida 1 en un archivo de texto. Para usuarios avanzados que conocen la estructura y signicado de estos archivos (descriptos en :ref:api), es deseable que tengan un acceso al contenido desde la propia aplicacin, para encontrar informacin numrica cuya precisin se pierde en un grco. Esta tarea se hace a travs de PubSub. El emisor enva un mensaje con tpico add_txt adjuntando como informacin una tupla con la ruta al archivo y el caso al que este clculo pertenence. Por ejemplo, la funcin que escribe el archivo de entrada para el clculo de parmetros es la siguiente:
def write_conparin(self, direction, model_id, data): """ Write the input file CONPARIN.DAT .
data could be compound constants (direction=0) or model paramater (d 0 -> [tc, pc, vc, omega]
Example: [u305.32, u48.72, u0.1455, u0.099493] """ filename = CONPARIN.DAT filepath = os.path.join(self.path_temp, filename) template = "{0} {1}\n {2}" if int(direction) == 0 and int(model_id) in (1,2,3):
En realidad, la llamada est intercedida por una funcin decoradora (memoize) que realiza un cach de los resultados la primera vez que se invoca. Si en sucesivas llamadas los parmetros coinciden, se devuelven los datos almacenados en memoria, tarea mucho ms rpida que recalcular.
1
8.1. Utilizacin de Publish/Suscribe en GPEC
61
Figura 8.2: Secuencia para la generacin de un diagrama desde el evento generado por el usuario 62 Captulo 8. Implementacin
Figura 8.3: Panel de navegacin y visualizacin de archivos en entrada y salida

data = data[:-2] + [data[-1], data[-2]] #t,p,v,o -> t,p,o,v elif int(direction) == 0 and int(model_id) in (4,6): data = data[:-2] + [data[-1]]
output = template.format (direction, model_id, " with open(filepath , w) as fh: fh.write(output) fh.close()
".join(map(str, data))
self.written.add((filename))
#conparin written
pub.sendMessage(add_txt, (filepath, self.case_id))
El atributo path_temp est denido en el constructor de la clase API y se trata de una ruta a un subdirectorio en la carpeta temporal, abstrada del sistema operativo subyacente mediante el mdulo tempfile El receptor de este mensaje es IOPanel que maneja el mensaje con el mtodo OnAddItem() .
def OnAddItem(self, msg): filepath, case_id = msg.data head,filename = os.path.split(filepath) if case_id not in self.cases.keys(): #if case is unknown, create it node = self.tree.AppendItem(self.root, "Case %d " % case_id) self.cases[case_id] = node else: node = self.cases[case_id]
with open( filepath, r) as fh: content = fh.read()
8.1. Utilizacin de Publish/Suscribe en GPEC
63
item = self.tree.AppendItem(node, filename) self.tree.SetPyData(item, content)
#self.tree.Expand(node) self.tree.SelectItem(item)
#TODO refresh text_ctrl?
8.1.4 Tabla de incidencias de mensajes

Se lista aqu una tabla con diferentes tipos de mensajes, su utilidad, emisor/es y destinatario/s: Tpico log add_txt clone case make.* refresh all active page Descripcin Mensaje al usuario Expone archivo de backend Crear un nuevo caso a partir del actual Invoca el clculo y genera el grco Refresca la interfaz de usuario Trae a primer plano una pestaa de los grcos Emisor/es varios ApiManager.* CasePanel.Clone Receptor/es LogMessagesPanel IOPanel TabbedCases
CasePaSuitePlotsPanel.OnMakePlots nel varios MainFrame PlotsTreePanel SuitePlotsPanel
Para un listado completo puede analizar el cdigo fuente ejecutando grep -r "pub.sendMessage" sobre el directorio de cdigo fuente raiz de GPEC. 2
8.2 Invocacin de ejecutables del backend

La comunicacin frontend-backend se describe en el diagrama de secuencia de la gura 8.4. All se resalta el ciclo de vida del objeto ApiManager donde est implementada la lgica de tratamiento de la interfaz de comunicacin. El caso particular representado es la obtencin de datos el clculo del diagrama de fase global (que se obtiene mediante el ejecutable GPEC.exe) satisfaciendo las precondiciones de ejecucin (por ejemplo, que exista el archivo de entrada GPECIN.DAT, que exista permiso de ejecucin, que exista permiso de escritura en la carpeta destino). En caso de error por algn motivo (conocido o no), se remite un mensaje de log y se cancela la ejecucin.
8.2.1 La dependencia con Wine

El backend de GPEC, codicado en Fortran por Cismondi, ha sido compilado mediante Microsoft Fortran y se compone de un conjunto de ejecutables Windows (.exe). Si bien
El comando grep -r busca de manera recursiva una cadena (o una expresin regular) sobre sobre los archivos de un directorio
2
64
Figura 8.4: Secuencia de la comunicacin frontend-backend
8.2. Invocacin de ejecutables del backend
65
el cdigo es Fortran estndar y compatible con compiladores libres (como GNU Fortran (http://gcc.gnu.org/fortran/) ) pudindose generar ejecutables especcos para sistemas Linux, existe una dependencia con la librera propietaria IMSL Numerical Libraries, que brinda un conjunto de rutinas matemticas (lgebra lineal, clculo matricial, etc.) que se utilizan en la implementacin de los algoritmos. Esta dependencia impide, por el momento, generar una versin completamente nativa para plataformas Linux (y, a priori, la posibilidad de liberar completamente el cdigo). Para permitir la ejecucin sobre Windows es necesario la utilizacin de Wine, un software que ofrece una capa de compatibilidad para aplicaciones DOS, Windows 3.x, y win32, proveyendo una implementacin alternativa (y parcial) del ncleo NT. A travs de Wine, los ejecutables Fortran de GPEC funcionan perfectamente. La funcin que invoca estos ejecutables verica el sistema operativo en que se est corriendo la aplicacin y en caso de no ser Windows, invoca a Wine:
args = [] if sys.platform != win32: #On any non-Windows system, we run binaries through wine args.append(wine) args.append( os.path.join(PATH_BIN, bin + .exe))
Nota: Esta dependencia es salvable utilizando la versin para Linux de la biblioteca IMSL pero que nicamente es compilable mediante Intel Fortran Composer (http://software.intel.com/en-us/articles/intel-composer-xe/) , con lo cual se duplica la dependencia de software privativo.
8.3 Memorizacin de resultados costosos

Como se observa la gura 8.4, el proceso de comunicacin y obtencin de los datos desde el backend no es trivial. Ms an, considerando que, dada la arquitectura heredada interviene de manera insalvable la escritura y lectura a disco, el proceso tambin es costoso 3 a nivel computacional. Tomando de ventaja de la condicin determinstica de la operacin (para los mismos parmetros de entrada, es decir el caso, se obtiene siempre el mismo resultado) se puede calcular una vez, guardar el resultado en memoria, y devolverlo sin recalcular cada vez que la operacin con exctamente los mismos parmetros es solicitada de nuevo. A este proceso se lo denomina cach de datos. Esto tiene validez, adems, dado que la probabilidad de que los parmetros sean los mismos es alta. Por ejemplo, en el siguiente caso de uso: El usuario necesita generar una isopleta para determinada composicin (o cualquier otra curva no global). Para esto, GPEC requiere haber calculado el diagrama
El mdulo cStringIO provee un tipo de buffer de cadenas de caractres con la misma interfaz que un archivo de texto normal. Las operaciones con la informacin en memoria son altamente ecientes.
3
66
global previamente (los ejecutables requieren GPECOUT.DAT como precondicin de entrada), de modo que este clculo se realiza sin mostrar los diagramas. Si posteriormente el usuario decide que necesita los diagramas globales, simplemente se gracan el respaldo en memoria sin realizar la el clculo mediante backend. Por ltimo, dado el manejo referencial de memoria que hace Python, la permanencia del array en memoria no est duplicada respecto al que se utiliza para gracar.
8.3.1 Patrn decorator

Una forma habitual de implementar el mecanismo de cach es a travs del patrn Decorator, que en trminos simplicados realiza una transformacin dinmica de una funcin o mtodo, agregndole una funcionalidad que no tiene por s misma, o ms en general, alterando de alguna manera el resultado devuelto.
Figura 8.5: Diagrama de clases del patrn Decorator Expresndolo en trminos matemticos, se trata de una composicin de funciones: X Y Z
x f (x) g (f (x)) Desde la versin 2.4, Python tiene una nomenclatura facilitada para la escritura de decoradores. Una estructura genrica para la denicin de una funcin decoradora, que se compone de un wrapper de dos funciones anidadas 4 , es la siguiente:
def mydecorator(function): def _mydecorator(*args, **kw):
Mientras que las velocidades de CPU y las capacidades de memporia se han incrementado enormemente, otros aspectos concernientes a la performance como las velocidades de acceso a disco se han quedado en el tiempo. Como consecuencia, estas latencias son cada vez ms seguido un cuello de botella en la performance global del sistema. http://en.wikipedia.org/wiki/Moores_law#Importance_of_non-CPU_bottlenecks
4
8.3. Memorizacin de resultados costosos
67
# hacer las tareas de decoracin # antes de llamar a la funcion decorada res = function(*args, **kw) # hacer otras cosas antes de devolver el resultado return res # se devuelve la subfuncin return _mydecorator
Cuando se tiene una funcin cualquiera que se quiere decorar, simplemente se utiliza la sintaxis @mydecorator justo antes de la funcin en cuestion. Por ejemplo:
@mydecorator def mifuncion(): pass
Al llamar a mifuncion() se obtiene en realidad mydecorator(mifuncion()). La ventaja sintctica de Python es que permite hacer esta llamada de manera implcita.
8.3.2 Algoritmo de cach de datos

El algoritmo utilizado para la implementacin del sistema de cach se llama memoize 5 y es descripto en detalle en [ZIADE2008] , cuya versin, parcialmente simplicada, se ha utilizado. En este caso, la funcionalidad que aporta el decorador a la funcin que se decora es la siguiente: 1. Se obtienen todos los parmetros de la funcin, se serializan en una cadena de texto, y con esa cadena se genera un hash, es decir, una clave de caracteres unvoca para ese conjunto de datos. Esta codicacacin es un proceso determinstico. 2. Se evalua si ese hash existe como clave en el diccionario que almacena resultados memorizados. 3. Dependiendo del resultado anterior a) Si la clave existe en el diccionario (o sea, el resultado para esos parmetros se calcul previamente) se devuelve el valor de la entrada sin llamar a la funcin decorada. b) Si la clave no existe (lo que implica que es la primera vez que se llama la funcin con los parmetros dados) se invoca a la funcin decorada y con el resultado se agrega una entrada en el diccionario hash:resultado. Adems, se devuelve el resultado.
8.3.3 Cdigo fuente

def compute_key(function, args, kw): key = pickle.dumps((function.func_name, args, kw)) return hashlib.sha1(key).hexdigest()
5
Tambin llamado memoization. Ver http://en.wikipedia.org/wiki/Memoization
68
def memoize(): def _memoize(function): def __memoize(*args, **kw): key = compute_key(function, args, kw) if key not in cache.keys(): #we havent it already? result = function(*args, **kw) cache[key] = result #store a new one else: print found in cache #TODO may be its a better idea #cache the whole arrays. return cache[key] return __memoize return _memoize
8.4 Algoritmo de anlisis sintctico

Como ya se ha hecho mencin, la comunicacin con los ejecutables del backend se realiza mediante archivos de texto. Los archivos de salida, en particular, contienen (en arreglos de columnas) los vectores de datos para cada variable de una curva. Segn [Vera1994], la tarea de delimitar la informacin de un texto se denomina en la lingistica Anlisis sintctico y es tambin un rea de la informtica de utilidad en la implementacin de diversos software (como ejemplo notorio, los compiladores). Este trabajo implementa un analizador sintctico (denominado parser, en ingles) para extraer los vectores numricos (ordenados como un arreglo bidimensionales) de los archivos de salida, obteniendo as la informacin necesaria para gracar cada curva. Nota: Para una comprensin cabal del algoritmo, es necesario estr familiarizado con la denicin de la interfaz. Una descripcin exhaustiva se expone en Especicacin de la interfaz de comunicacin.
8.4.1 Descripcin
El algoritmo se basa en identicar tokens (marcas) que declaran el inicio y nal de informacin vlida para un diagrama, determinando as la porcin de texto (nmeros otantes en formato texto) que debe extraerse. Este texto se convierte a un objeto array de numpy. Las marcas de inicio son cadena de tres letras maysculas (VAP,CRI,LLV, etc.) y un rengln vaco marca el nal del bloque de informacin como se muestra en la gura 8.6. Una estructura de datos basadas en asociaciones clave-valor (diccionarios), dene los tipos posibles de curvas y las columnas signicativas que se deben extraer para cada una. Iterando sobre todas las lneas del archivo se obtiene un nuevo diccionario cuya clave es una tupla de la forma (inicio, fin) y el tipo de curva como valor. 8.4. Algoritmo de anlisis sintctico 69
Figura 8.6: Topologa de la informacin extractada Con esta informacin simplemente se recorta el archivo de texto completo del cual se realiza una copia residente en memoria 6 para importarlo y convertirlo a arreglos de nmeros otantes de doble precisin mediante la funcin numpy.loadtxt() que acepta como parmetro opcional la cantidad de columnas signicativas que deben interpretarse 7 .
8.4.2 Cdigo fuente

def output2array(self, filepath, curve_types): """Parses gpecout.dat, PXYOUT.DAT TXYOUT.DAT or ISOPOUT.DAT Detects numeric blocks and create arrays with them""" tokens = {} begin = 0 end = 0 #{(begin,end):type, ...}
with open(filepath, r) as fh: number_of_lines = len(fh.readlines()) fh.seek(0) #give skip from header and skip from footer
Cuando se necesita pasar parmetros especcos al decorador (adems de los que se pasan en la llamada a la funcin decorada) se necesita una forma sutilmente ms compleja, donde la declaracin del decorador tiene un subnivel ms de wrappering, o sea, 3 funciones anidadas. 7 Una referencia completa de esta funcin se encuentra en http://docs.scipy.org/doc/numpy/reference/
6
70
for line_number, line in enumerate(fh): if begin <= end: #looking for a curve TOKEN : VAP, CRI etc... if line.strip() in curve_types: begin = line_number + 1 curve_type = line.strip() elif not line.strip() or line_number==number_of_lines-1: #looking for a blank line which determines the end of #arrays block. end = line_number tokens[(begin, end)] = curve_type arrays_out = {} #Format: {type: [array1,array2, ...], ...}
for (begin, end), curve_type in sorted(tokens.items()): fh.seek(0) temp_w = cStringIO.StringIO()
#a memory file to write
#write lines just of the block between (begin,end) for l,line in enumerate(fh): if begin <= l < end and \ len(get_numbers(line))>0: #a way to check the special case of col #headers after mark temp_w.write( line.replace(*, ) ) #a copy to read temp_r = cStringIO.StringIO(temp_w.getvalue()) #retrieve significative columns from a dictionary. #(begin,end)=>type=>num_cols signif_cols= range(curve_types[tokens[(begin, end)]]) curve_array = np.loadtxt(temp_r, usecols=signif_cols) temp_w.close() temp_r.close() #if its a new type on the dict, create it. if curve_type not in arrays_out.keys(): #TODO should it be a ndarray ? arrays_out[curve_type] = [] arrays_out[curve_type].append(curve_array) fh.close()
8.4. Algoritmo de anlisis sintctico
71
return arrays_out
8.5 Interfaz Grca de Usuario (GUI)

La interfaz grca fue objeto de estudio. La pantalla principal est dividida en cuatro paneles (subventanas) que permiten la entrada de datos (Cases), la visualizacin de grcos (Plots), informaciones tiles como mensajes de usuario y los archivos de entrada/salida sin procesar (Info) y el navegador de vistas en forma de rbol (Manager). Esta divisin se deni para dar soporte al requerimiento de mltiples casos y grcos permitiendo navegar fcilmente entre los distintos resultados, de manera de facilitar la comparacin sin complejizar la interfaz.
8.5.1 Contenedores y sizers

En la introduccin general a WxPython vista en Tecnologas adoptadas se hizo referencia a la clase wx.Panel describindola como un contenedor de otros objetos grcos. Tradicionalmente, uno de los problemas ms complicados en la programacin de GUI es el manejo de la disposicin fsica de los componentes en el espacio disponible (layout). En los comienzos, la solucin fue el posicionamiento absoluto donde el programador explicitaba el tamao y la posicin excta del widget en la pantalla 8 . Esta estrategia acarrea una batera de problemas ya que slo funciona correctamente si se tiene control total sobre el espacio disponible, es decir, controlando la resolucin de pantalla del equipo del cliente, el tamao de tipografa estndar que ha elegido, etc. pero se vuelve inmanejable cuando el layout es dinmico, es decir, que cambia en funcin de alguna accin del usuario. Para solucionar este problema wxPython, y en general, todos los frameworks para la construccin de GUIs modernas, utilizan el concepto de sizers, que son algoritmos automticos que distribuyen los elementos de la interfaz de una menera predeterminada. Un sizer en wxPython es un objeto invisible que no es un contenedor (como son, por ejemplo, Panel, Frame o una pgina de un elemento wx.Notebook) sino que simplemente indican cmo se ubican originalmente y cmo se comportan visualmente los elementos ante un evento que afecte la apariencia de la aplicacin. Todo los sizers son instancias de una subclase de la clase abstracta wx.Sizer Ver Tambin: Para una explicacin exhaustiva sobre el tema, vea el capitulo 11 de wxPython in Action, [NR-RD2006] Por ejemplo, sizer permite dividir el espacio, cualquier este sea, en porciones proporcionales de las o columnas, y ubicar all elementos (como botones o campos de texto), deniendo atributos como su alineacin horizontal o vertical, el tamao (proporcional al espacio, jo,
8
Una aproximacin de este tipo, relativa al tamao de la ventana, utiliza la versin anterior de GPEC.
72
con lmite mximo, etc). Asmismo, un sizer puede contener a otros de manera anidada, deniendo una cuadrcula con espacios para ubicar los widgets controladores 9 .
Figura 8.7: Diseo con sizers de una ventana de la aplicacin mediante la utilidad wxGlade (http://wxglade.sourceforge.net) El hecho de que un sizer no sea un contenedor indica que parent de cualquier elemento an debe serlo. Es decir, un elemento cualquier (por ejemplo, un botn) est en incrustado en un contenedor (por ejemplo, un panel) pero ubicado segn indica un sizer que est asociado al mismo contenedor. Uso en la aplicacin En GPEC, toda la distribucin de componentes de la interfaz est dispuesta a travs de sizers. Como ejemplo, en la gura 8.8 se muestra la parte superior de un panel para la denicin de un caso donde consta el uso anidado de sizers de distinta clase. Se observa que existe un panel contenedor principal, CasePanel cuyo sizer principal es por las (wx.BoxSizer(wx.VERTICAL)) al que se le suman 2 instancias del panel , VarsAndParamsPanel (slo se muestra uno, pero corresponde 1 para cada compuesto del sistema binario) cuyo layout se basa en un wx.GridBagSizer de 6 las por 5 columnas.
Para layout de estilo cuadrcula se utiliza una de las implementaciones de la clase abstracta wx.Sizer es GridSizer
9
8.5. Interfaz Grca de Usuario (GUI)
73
Figura 8.8: Distribucin mediante sizers de componentes. El contenido del GridBagSizer es dinmico, cambiando su contenido en funcin de un evento de cambio de opcin (evento wx.EVT_CHOICE) del men de modelos. La porcin de cdigo relevante se describe a continuacin:
class CasePanel(scrolled.ScrolledPanel): def __init__(self, parent, id): scrolled.ScrolledPanel.__init__(self, parent, id, style = wx.TAB_TRAVERSAL | wx.CLIP_CHILDREN | wx.FULL_REPAINT_ON_RESIZE)
self.box = wx.BoxSizer(wx.VERTICAL) # <- sizer principal self.model_choice = wx.Choice(self, -1, choices = sorted(self.model_options.keys()))
first_row_sizer = wx.BoxSizer(wx.HORIZONTAL) # <- sizer secundario self.load_button = wx.lib.buttons.GenBitmapTextButton(self, -1, wx.Bitmap(os.path.join(PATH_ICONS,"compose.png")), "Define system") first_row_sizer.Add(self.load_button, 0, flag=wx.ALL | wx.ALIGN_LEFT | wx.EXPAND , border=5) first_row_sizer.Add((10, 20), 0, wx.EXPAND) first_row_sizer.Add(wx.StaticText(self, -1, "Model:")) first_row_sizer.Add(self.model_choice) # <- menu
74
self.box.Add( first_row_sizer, 0, flag= wx.TOP | wx.LEFT | wx.FIXED_MINSIZE | wx.ALIGN_LEFT, border = 5)
self.panels = (VarsAndParamPanel(self,-1), VarsAndParamPanel(self,-1)) self.box.Add(self.panels[0], 0, wx.EXPAND ) self.box.Add(self.panels[1], 0, wx.EXPAND ) # <-- subpanel 1
class VarsAndParamPanel(wx.Panel): """a panel with 2 columns of inputs. First colums input EOS variables. The second one are the inputs to model parameters (change depending the model selected). This parameter are related and is possible to calcule a group of values defining the other one. """ def __init__(self, parent, id, model_id=1, setup_data=None): """setup_data: (id, name, tc, pc, vc, om)""" wx.Panel.__init__(self, parent, id, style = wx.TAB_TRAVERSAL | wx.CLIP_CHILDREN | wx.FULL_REPAINT_ON_RESIZE ) gbs = self.gbs = ui.widgets.GridBagSizerEnh(6, 5)
La aplicacin de sizer repercute en la homogeneidad y determinismo de la ubicacin de los componentes, lo que permite aplicar las caractersticas de usabilidad mostradas en la gura 8.9, cuya base conceptual se menciona en en Preceptos adoptados en el diseo de UI .
8.5.2 El uso de la Advanced User Interface

La ventana principal de la aplicacin MainFrame denida en aui.py es una de subclase de la clase wx.Frame pero el manejo de la distribucin de sus componentes se basa en una librera especial denominado Advanced User Interface, que reside en wx.aui. Esta librera est construida sobre la pila de componentes de wxPython y permite implementar interfaces avanzadas a travs del control de subventanas automatizado de eventos como maximizar (ocupar toda la ventana principal), cerrar (no se muestra en la ventana principal) o restaurar (vuelve a la posicin original) entre otras. Comparando con los resultados que se obtienen, utilizar wx.aui tiende a ser trivial. Bsicamente consiste en dos objetos: Un manejador, wx.aui.AuiManager, que se encarga de toda la lgica de control, 8.5. Interfaz Grca de Usuario (GUI) 75
Figura 8.9: Caractersticas de usabilidad implementadas en el panel
76
mantener el estado de las ventanas y lanzar los mtodos automticos cuando ocurren eventos sobre la interfaz. Al menos una instancia wx.aui.AuiPaneInfo que dene una subventana a la que se le asocia el contenido a mostrar, en general, un panel principal de wx.
Figura 8.10: La interfaz avanzada de GPEC visualizando 2 de los 4 paneles por defecto. Vale comentar que luego de cualquier cambio, yendo a :menuselection:View > Restore default view se reestablece la estructura original. Un extracto relevante de MainFrame es el siguiente:
class MainFrame(wx.Frame): def __init__(self, parent, id=-1, pos=wx.DefaultPosition, title=GPEC, size=(800,600), style=wx.DEFAULT_FRAME_STYLE | wx.MAXIMIZE ): wx.Frame.__init__(self, parent, id, title, pos, size, style=style) self._mgr = wx.aui.AuiManager(self) self.cases_panel = TabbedCases(self, -1) self.cases_auipane = wx.aui.AuiPaneInfo().Name("cases").\ Caption(u"Cases").Left().MinSize(the_size).MaxSize(the_size).\ Layer(1).Position(2).CloseButton(True).MinimizeButton(True) #<- manejador
8.5. Interfaz Grca de Usuario (GUI)
77
self._mgr.AddPane(self.cases_panel, self.cases_auipane ) self._mgr.Update() self.Maximize()
En el cdigo se observa la siguiente secuencia 1. Se instancia el manejador de wx.aui 2. Se instancia el panel de contenido, en este caso TabbedCases 3. Se instancia la subventana wx.aui.AuiPaneInfo con todas sus propiedades (ubicacin, ttulo, tamao mnimo, etc. ) 4. Se dene que el contenido de la subventana ser el panel antes generado y se lo agrega al manejador. 5. Se actuliza el layout Una observacin en el paso 3 es que para denir los atributos del panel se utiliza una tcnica denominada encadenado de mtodos (Method chaining) 10 donde la ejecucin de un mtodo de un objeto devuelve el objeto en s, posibilitando encadenar la ejecucin de otro mtodo. La interfaz por defecto de GPEC se compone de 4 instancias de AuiPaneInfo cuyo contenido se lista en la siguiente tabla: Ttulo Cases Plots Manager Info Panel de contenido TabbedCases SuitePlotsPanel PlotsTreePanel InfoPanel Descripcin del contenido Denicin de casos Pestaas de grcos rbol de manejo grcos Panel de informaciones diversas
8.5.3 La gestin avanzada de pestaas

En el rea de las interfaces grcas de usuario, la navegacin por pestaas (TABBED DOCU MENT INTERFACE (TDI)) se reere a la posibilidad de que varios paneles con informacin estn contenidos dentro de una sola ventana o panel principal, usando pestaas para alternar entre ellos. Es tpico su uso en los navegadores web modernos, como Mozilla Firefox. GPEC hace uso extendido de esta arquitectura, en el soporte de mltiples casos, mltiples grcos, o varios paneles de informacin. En wxPython existen mltiples implementaciones de controladores de pestaas y se ha hecho uso de AuiNotebook, que forma parte de las Advanced Generic Widgets (http://xoomer.virgilio.it/innity77/AGW_Docs/) (AGW ) desarrolladas por el programador italiano Andrea Gavana. Toda la librera AGW forma parte del paquete estndar de wx y reside en wx.lib.agw.aui. La gran ventaja de AuiNotebook es que funciona como complemento de la intefaz avanzada de Python wx.aui permitiendo el control de eventos como drag & drop de pestaas entre
Esta tcnica es ampliamente utilizada en frameworks Javascript como jQuery <http://jquery.com>, dada que su alta expresividad produce cdigo ms compacto, caracterstica muy relevante en el ambiente web. Ver http://en.wikipedia.org/wiki/Method_chaining
10
78
distintos paneles, o la visualizacin simultnea de mltiples pestaas, como muestra la gura 8.11.
Figura 8.11: El control AuiNotebook de los grcos mostrando 2 diagramas en simultneo
8.6 Integracin Matplotlib-WxPython

La biblioteca de gracacin Matplotlib incluye soporte para los toolkits para creacin de interfaces grcas 11 ms utilizados, que permite incrustar (y hacer interactuar) guras dentro de aplicaciones grcas. La integracin entre Matplotlib y WxPython se logra a travs de un canvas (lienzo) donde Matplotlib es capaz de dibujar y, se comporta, a la vez como un panel de wxPython. El objeto en cuestion es FigureCanvasWxAgg. Se muestra su ascendencia de clases en el diagrama de la gura 8.12. La clase FigureCanvasAgg es en realidad la encargada de dibujar los grcos a travs de los algoritmos Anti-Grain Geometry (http://www.antigrain.com) que aplican tcnicas como Anti-Aliasing 12 o Precisin de subpixel para mejorar la denicin de la lneas trazadas. Por su parte, la otra clase padre FigureCanvasWx es la que realiza la integracin concreta con wxPython, heredando de un contenedor tipo wx.Panel.
El soporte incluye GTK, QT4, TKinter, PDF y wxPython Es un proceso utilizado para suavizar los bordes http://es.wikipedia.org/wiki/Antialiasing
12 11
desparejos
de
los
grcos.
Ver
8.6. Integracin Matplotlib-WxPython
79
Figura 8.12: Diagrama de clases para FigureCanvasWxAgg donde se evidencia la herencia mltiple que permite el comportamiento dual del objeto. La gura 8.13 muestra la secuencia de eventos para la gracacin de un diagrama. Puede ver la seccin Tipos de grcos para estructura de clases implementada para dar soporte a los distintos tipos de grcos.
8.6.1 Barra de herramientas de grcos

Matplotlib provee una integracin avanzada con Wx proveyendo un barra de herramientas asociada al canvas integrable en la interfaz de usuario. Esta barra de herramientas provee zoom, denicin de margenes, desplazamiento, exportacin y navegacin histrica 13 La exportacin permite guardar el estado actual del diagrama, incluyendo tamao, curvas visibles, etiquetas, grilla, etc. en distintos formatos escalables como PDF, SVG, EPS, o de mapa de bits como PNG entre muchos otros. La integracin es muy sencilla y se logra mediante la clase NavigationToolbar2Wx que se encuentra en el mdulo general de integracin con wx matplotlib.backends.backend_wxagg . El cdigo se resume a la instanciacin, indicando el objeto canvas al que se asocian las herramientas y a la ubicacin en un sizer:
self.toolbar = NavigationToolbar(self.plot.canvas) #the canvas from plot self.vbox = wx.BoxSizer(wx.VERTICAL) self.vbox.Add(self.plot.canvas, 1, wx.LEFT | wx.TOP | wx.GROW) self.vbox.Add(self.toolbar, 0, wx.EXPAND)
Permite aumentar la resolucin contemplando precisiones de fracciones de un pixel. Ver http://en.wikipedia.org/wiki/Sub-pixel_resolution.
13
80
Figura 8.13: Diagrama de secuencia para la gracacin de un diagrama al nivel subyacente (via matplotlib)
81
Figura 8.14: Barra de herramientas provista por Matplotlib integrable en wxPython
8.6.2 Integracin de mens contextuales

Otro aspecto de la integracin, un poco ms complejo, son los mens contextuales que permiten al usuario manipular la gura de diferentes manera, u ocultar y volver a mostrar las diferentes curvas.
Figura 8.15: Men contextual sobre una gura que se activa ante un evento con el botn derecho. La complejidad est dada por el paso de eventos entre wxPython y Matplotlib. El primero, en la clase PlotPanel dene y construye el men contextual pero asocia las acciones a mtodos de BasePlot:
def onMouseButtonClick(self, event): if event.button == 3: if not hasattr(self, menu): self.menu = wx.Menu()
for curve in self.plot.curves: self.menu.Append(curve[wx_id], curve[name], kind=wx.ITEM self.Bind(wx.EVT_MENU, self.plot.OnToggleCurve, id=curve[wx self.menu.Check(curve[wx_id], True) self.menu.AppendSeparator()
82
for prop, wx_id in self.plot.properties_normal.iteritems(): self.menu.Append(wx_id, prop) self.Bind(wx.EVT_MENU, self.plot.OnSetupProperty, id=wx_id)
for prop, wx_id in self.plot.properties_check.iteritems(): self.menu.Append(wx_id, prop, kind=wx.ITEM_CHECK) self.Bind(wx.EVT_MENU, self.plot.OnToggleProperty, id=wx_id) # Popup the menu. If an item is selected then its handler # will be called before PopupMenu returns. wx.CallAfter(self.PopupMenu, self.menu)
Los mtodos OnToggleCurve y OnSetupProperty son los que realizan las tareas solicitadas, como cambiar a escala logartmica, ocultar o mostrar una curva, etc.
def OnToggleCurve(self, event): wx_id = event.GetId() curve = [curve for curve in self.curves
if curve[wx_id] == wx_id][0]
curve[visible] = not curve[visible] for line in curve[lines2d]: try: line.set_visible(curve[visible]) except AttributeError: for line_ in line: line_.set_visible(curve[visible]) self.canvas.draw()
def OnSetupProperty(self, event): wx_id = event.GetId() prop = dict([[v,k] for k,v in self.properties_normal.items()])[wx_id] #i if prop == Set perspective...:
dlg = wx.TextEntryDialog(self.parent, uAzimuthal angle, uSet Perp defaultValue=str(self.axes.azim) ) r = dlg.ShowModal() if r == wx.ID_CANCEL: return elif r == wx.ID_OK: azim = float(dlg.GetValue())
dlg = wx.TextEntryDialog(self.parent, uElevation angle, uSet Perp defaultValue=str(self.axes.elev) ) r = dlg.ShowModal() if r == wx.ID_CANCEL: return elif r == wx.ID_OK: elev = float(dlg.GetValue())
83
self.axes.view_init(elev, azim)
elif prop == Set plot title...: dlg = wx.TextEntryDialog(self.parent, uPlot title, uSet plot titl defaultValue=self.axes.get_title() ) r = dlg.ShowModal() if r == wx.ID_CANCEL: return self.title = dlg.GetValue() self.axes.set_title(self.title) self.canvas.draw()
8.7 Implementacin de base de datos

El almacenamiento y gestin de la informacin necesaria de la base de datos denida en Capa de base de datos como entrada para GPEC se realiza a travs de un sistema de gestin de base de datos relacional. Se utiliz el software sqlite (http://sqlite.org) (versin 3) que respeta el estndar SQL (Structured Query Language) mediante una librera monoltica, portable, eciente y compacta que es integramente soportada por Python 14 . La ventaja principal es que una base de datos de sqlite est autocontenida en un archivo binario que puede ser distribuido en conjunto con el software, sin requerir inicializacin o un servidor de base de datos local o remoto. En este sentido es equivalente a una base de datos de Microsoft Access, aunque superadora en las prestaciones y apego a un lenguaje estndar para base de datos.
8.7.1 Denicin de la estructura de tablas

CREATE TABLE "compounds" ("id" INTEGER,"id_category" INTERGER PRIMARY KEY AUTOINCREMENT NOT NULL , "name" VARCHAR, "formula" VARCHAR, "formula_extended" VARCHAR, "tc" FLOAT, "pc" FLOAT, "vc" FLOAT, "acentric_factor" FLOAT, "vc_rat" FLOAT DEFAULT (1.168) ); CREATE TABLE "categories" ("id_category" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
Cada vez que se modica la visualizacin de la gura (un acercamiento, un desplazamiento, etc) se marca un hito en la historia, al que se puede regresar mediante las echas de navegacin.
14
84
"name" VARCHAR, "editable" BOOL NOT NULL DEFAULT True ); INSERT INTO "categories" VALUES(1,DIPPR,False); INSERT INTO "categories" VALUES(2,User defined,True);
8.7.2 Importacin de datos

Los datos fueron obtenidos de la versin preexistente (Visual GPEC) cuya base de datos, como se ha comentado en la seccin Problemas detectados, est en formato MS Jet. La obtencin de la informacin contenida para su conversin a Sqlite se realiz utilizando un proceso de 2 pasos 1. Con la herramienta gmdb2, parte de la suite de utilidades libres para la manipulacin de archivos Jet/Access MDB tools (http://mdbtools.sourceforge.net/), se export la tabla de parmetros de compuestos a un formato CSV (Comma Separeted Values) donde cada registro constituye una lnea de texto plano y los valores estn separados por un caracter (en particular se utiliz el punto y coma ;). El formato CSV, es un mecanismo cannico para la exportacin e importacin de datos, por su trivial facilidad de manipulacin. 2. Denida la estructura de la base de datos de destino (Sqlite), se utiliz la herramienta sqlite-manager (http://code.google.com/p/sqlite-manager/) para importar las columnas pertinentes del archivo CSV a la tabla de destino
Figura 8.16: Procesos de conversin de la base de datos a sqlite
8.7. Implementacin de base de datos
85
86
CAPTULO 9
Vericacin
Este captulo describe el trabajo realizado para la vericacin del correcto funcionamiento de la aplicacin. En particular se ha testeado la librera de comunicacin, es decir la clase ApiManager del mdulo apimanager
9.1 Conceptos de pruebas unitarias

Unit Testing o pruebas unitarias son test en donde cada parte (mdulo, clase, funcin) del programa es testeado por separado (de all lo de unitario). Idealmente, se pone a prueba todas las funciones y todos los casos posibles para cada una de ellas. Segn [Zulberti2010], el unit testing tiene varias ventajas: Permite probar que el programa funciona correctamente. En Python, los tests tambin permiten identicar variables que no existen o tipos esperados en las funciones (en otros lenguajes eso se hace en tiempo de compilacin). Permite identicar en caso de que se haga una modicacin que siga funcionando correctamente todas las parte del programa. Tanto las cosas modicadas como las cosas que dependen de las modicadas. Esto es muy importante cuando se trabaja en grupo (con algn sistema de control de versiones) ya que permite asegurar que el cdigo que usa el resto del grupo y que uno modico sigue funcionando. Permiten documentar el cdigo. Esto no es en forma directa, pero como los tests indican como es que se tiene que comportar el programa, viendo los tests uno puede jarse cul es el resultado esperado para ciertas entradas del programa. Esto no excluye que se tenga que escribir la documentacin del cdigo. Es muy importante que un test cumpla las siguientes reglas: Tiene que poder correr sin interaccin humana. Es decir, los tests no deben pedir que el usuario ingrese valores en ningn caso. Para esto, es en el test mismo cuando se pasan los valores a la funcin.
87
Tienen que poder vericar el resultado de la ejecucin sin interaccin humana. De nuevo, para saber si esta bien o no el resultado no tiene que pedirle al usuario que verique el resultado. Para esto, se tiene que saber de antemano el resultado del test con los valores que se pasaron. Un test tiene que ser independiente del otro. Es decir, el resultado de un test no debera depender del resultado anterior.
9.1.1 Unit testing en Python

Python provee en su librera estndar un completo framework para realizar pruebas unitarias. Se trata de unittest 1 cuya arquitectura y api est basada en el framework Junit (http://www.junit.org/) para el lenguaje Java. Nota: El testing en todas sus formas tiene amplio inters en la comunidad de usuarios de Python y adems del framework estndar existen gran cantidad de herramientas para facilitar distintos aspectos de la. Ver The Python Testing Tools Taxonomy (http://pycheesecake.org/wiki/PythonTestingToolsTaxonomy) En particular, se utiliz el framework unittest2 que forma parte estndar de la versin 2.7 de Python, y existe como backport para las versiones 2.4 a 2.6 2 . unittest provee muchas clases y funciones utilitarias para realizar pruebas automatizadas de la cuales se utiliz la estructura ms tradicional basada en la clase TestCase. Todos los mtodos de una subclase de TestCase cuyo prejo es test_ son ejecutados como una prueba, cuya estructura general es realizar una accin y comparar el resultado producido con el resultado esperado. Dependiendo de la condicin analizada, que se realiza mediante alguno o varios de los mtodos que comienzan con assert (assertEqual, assertNotEqual, assertGreatEqual, etc,) todos heredados de la clase TestCase, la prueba es exitosa o falla. Existen adems dos mtodos especiales setUp()() y tearDown() que se ejecutan automticamente (antes y despues, respectivamente) de ejecutar cada test.
9.2 Pruebas realizadas

Como se dijo, varias pruebas fueron realizadas sobre el controlador de la interfaz de comunicacin. Por supuesto, en un sistema tan complejo como el desarrollado la cobertura de pruebas dista de ser total, pero se ha vericado el mdulo ms complejo y por ende propenso a introducir errores. Se listan a continuacin la batera de test realizados.
La documentacin completa de la versin utilizada se encuentra en http://docs.python.org/library/unittest.html 2 El paquete backported se encuentra en la direccin http://pypi.python.org/pypi/unittest2 y se puede instalar fcilmente mediante el utilitario easy_install.
1
88
Captulo 9. Vericacin
class test_apimanager.TestApiManager(methodName=runTest) setUp() inicializador de cada test test_gpecout_1() Prueba que hay 2 curvas de vapor y al menos una crtica en los arrays de datos de numpy test_read_conpaout_1() Prueba que para todos los modelos, la primer la de resultados tiene 4 parmetros y la segunda 3 excepto para RK-PR que son 4 test_write_conparin_1() Direccin 0 para modelos de clculo 1 2 o 3. Prueba que se invierte el orden de los ltimos dos parmetros. test_write_conparin_2() Prueba que la primer linea es [direction, model_id] test_write_conparin_3() Prueba que no se incluye el parmetro Vc test_write_gpecin() Prueba que se satisface la estructura de GPECIN.DAT
9.2.1 Ejemplos de cdigo de las pruebas

El cdigo de implementacin de cada una de estas pruebas es muy descriptivo pero por una cuestin de extensin, se muestran slo algunos de ellos. Para el estudio completo ver el mdulo test_apimanager.py Ejemplo 1
def test_write_conparin_1(self): """ Direccin 0 para modelos de clculo 1 2 o 3. Prueba que se invierte el orden de los ltimos dos parmetros. """ direction = 0 model_id = random.choice([1,2,3]) t, p, v, o = data = [str(random.random()) for x in range(4)] self.api.write_conparin(direction, model_id, data) output = self.file2list(CONPARIN.DAT) self.assertEqual(output[1], [t, p, o, v])
9.2. Pruebas realizadas
89
Ejemplo 2
def test_read_conpaout_1(self): """ Prueba que para todos los modelos, la primer fila de resultados tiene 4 parmetros y la segunda 3 excepto para RK-PR que son 4 """ direction = 0 data = [469.7, 33.7, 0.313, 0.251506] # n-pentane for model_id in settings.EOS.values(): output = self.api.conparin2conparout(direction, model_id, data) self.assertEqual(len(output[0]), 4) if model_id == 3: self.assertEqual(len(output[1]), 4) else: self.assertEqual(len(output[1]), 3)
Ejemplo 3
def test_gpecout_1(self): """ Prueba que hay 2 curvas de vapor y al menos una crtica en los arrays de datos de numpy """ model = 1 #random.choice([1,2,4,6])
data1 = [190.56, 45.99, 0.0115, 0.114837] #methane data2 = [514, 61.37, 0.6436, 0.232124] #ethanol data1, param1 = self.api.conparin2conparout(0, model, data1) data2, param2 = self.api.conparin2conparout(0, model, data2) comp1 = (uMETHANE, data1, param1) comp2 = (uETHANOL, data2, param2) data = self.api.gpecin2gpecout(model, comp1, comp2) self.assertEqual(len(data[VAP]), 2) self.assertGreaterEqual(len(data[CRI]), 1)
9.2.2 Ejecucin y validacin

Se muestra la ejecucin automatizada de todas las pruebas y su resultado exitoso:
tin@azulita:~/facu/pi/src$ python test_apimanager.py test_gpecout_1 (__main__.TestApiManager) ... ok
90
test_read_conpaout_1 (__main__.TestApiManager) ... ok test_write_conparin_1 (__main__.TestApiManager) ... ok test_write_conparin_2 (__main__.TestApiManager) ... ok test_write_conparin_3 (__main__.TestApiManager) ... ok test_write_gpecin (__main__.TestApiManager) ... ok ---------------------------------------------------------------------Ran 6 tests in 0.808s OK
9.3 Pruebas de usabilidad

Para analizar la mejora respecto a la versin preexistente se realizaron pruebas con usuarios con el objetivo de observar el xito en la tarea encomendada. La pruba se bas en mtodos propuestos por el reconocido consultor Jakob Nielsen, en en [Nielsen2000] y [Nielsen2009]. Las condiciones experimentales de estas pruebas fueron: Cinco usuarios trabajando individualmente Se solicita la obtencin de una suite de grcos No se da ninguna otra intruccin ni ayuda oral o escrita sobre cmo lograr el resultado Si bien la muestra poblacional no fue representativa para una conclusin denitiva, los cinco usuarios lograron el objetivo en menos de 2 minutos, aun aquellos que no comprendieron, por ser ajenos a la disciplina, el signicado de los diagramas obtenidos. Las tareas de manipulacin de los diagramas como rotar (sobre diagramas 3D), hacer zoom, desplazar, etc. fueron bien interpretadas mediate los conos de la barra de herramientas. Como experiencia adicional se menciona que en las clases prcticas realizadas en el marco de los laboratorios de la ctedra Termodinmica (Ingeniera Qumica, UNC), dictador por el Dr. Cismondi, la gran mayora de los usuarios (superior al 75 % de un curso de 25 alumnos) lograron realizar los diagramas antes de que se impartieran las instrucciones para obtenerlos.
9.3.1 Anlisis cuantitativo

Se describen algunos aspectos cuantitativos que dan muestra de la reduccin de componentes de control y acciones necesarias para realizar una tarea, comparando la versin actual con la anterior. Panel de denicin de un caso Visual GPEC 38 componentes simultneos 3 grupos de opciones Opciones secundarias visibles 100 % espacio pantalla GPEC 2010 19 componentes 2 menues de opciones Opciones secundarias desplegables 25 % espacio de pantalla
9.3. Pruebas de usabilidad
91
Denicin un sistema de componentes arbitrarios Visual GPEC 3 ventanas modales 7 clicks 15 cajas de texto GPEC 2010 1 ventana modales 4 clicks 5 cajas de texto
92
CAPTULO 10
Implantacin
10.1 Empaquetado para sistemas Windows

Como requisito, se especic que GPEC deba ser capaz de ejecutarse en plataformas Windows y Linux. Para satisfacer esta condicin la tecnologa utilizada se eligi intrnsecamente multiplataforma, aunque el ambiente de desarrollo principal haya estado basado en Linux. Por supuesto, para realizar pruebas de compatibilidad y asegurar el funcionamiento en windows, se debi instalar un ambiente anlogo con versiones para este sistema operativo. Sin embargo, la distribucin del software para usuarios Windows no puede basarse en la reproduccin de un ambiente de desarrollo, es decir, la instalacin por separado del lenguaje Python (intrprete) y las diversas bibliotecas necesarias para la ejecucin del software. Esto, en primer lugar, porque complica la utilizacin al usuario inexperto, y en segundo lugar porque resulta ineciente en trminos de tamao teniendo en cuenta que slo parte (algunos mdulos) de las bibliotecas intrnsecas de Python y las bibliotecas de terceros son utilizadas en GPEC. Por poner un ejemplo, la biblioteca de gracacin Matplotlib incluye soporte para la integracin con otras bibliotecas para interfaces grcas (como Qt, GTK, etc ) que no son utilizadas en GPEC al estar basada, como se ha especicado, en WxWidget.
10.1.1 Py2exe: separar slo lo necesario

Para realizar el estudio de cules son los mdulos (y sus respectivas dependencias) unvocamente necesarios se utiliz el software py2exe (http://www.py2exe.org/) py2exe es una extensin a las Python Distribution Utilities (distutils) que convierte scripts de Python en aplicaciones ejecutables en windows (.exe) sin requerir la instalacin por separado del intrprete o bibliotecas. Partiendo de un ambiente de desarrollo Windows con todos los requerimientos satisfechos, py2exe realiza un rbol de dependencias y genera una carpeta incluyendo nicamente los mdulos estrictamente necesarios, as como una copia de las libreras dinmicas (.dll) necesarias para la ejecucin. Adems, puede realizar la conversin del cdigo python a bytecode (formato
93
binario ms rpidamente interpretable por Python) y agregar una cierta compresin, de manera de optimizar el tamao del paquete resultante.
Figura 10.1: Salida nal de la ejecucin de py2exe enumerando las libreras dinmicas complementarias que son necesarias para la ejecucin del programa. Todas estas son comunes en cualquier instalacin por defecto de Windows. La conguracin de py2exe se realiza a travs de un mdulo estndar de las Distutils denominado setup.py. All se especican variables y directrices necesarias, como el nivel de compresin, cul es el mdulo principal (que ser convertido en el .exe), datos extra que deben ser includos (por ejemplo, la base de datos), etc. El setup.py de GPEC es el siguiente:
from distutils.core import setup import py2exe import matplotlib data = matplotlib.get_py2exe_datafiles() data += [LICENSE.txt] includes = [numpy.core.umath] excludes = [_gtkagg, _tkagg, bsddb, curses, email, pywin.debugger, pywin.debugger.dbgcon, pywin.dialogs, tcl, Tkconstants, Tkinter] packages = [] dll_excludes = [libgdk-win32-2.0-0.dll, libgobject-2.0-0.dll, tcl84.dll, tk84.dll] setup( data_files = data, options = {"py2exe": {"compressed": 2,
94
Captulo 10. Implantacin
"optimize": 0, #2, "includes": includes, "excludes": excludes, "packages": packages, "dll_excludes": dll_excludes, "bundle_files": 3, "dist_dir": "dist", "xref": False, "skip_archive": False, "ascii": False, "custom_boot_script": , } }, windows=[aui.py] )
El resultado de py2exe es una carpeta ./dist que incluye todo el cdigo fuente de la aplicacin en formato bytecode con todas las bibliotecas necesarias as como el intrprete de Python empaquetado como biblioteca dinmica.
Figura 10.2: Resultado de la ejecucin de py2exe Ejecutando aui.exe se ejecutara la aplicacin distribuible.
10.1. Empaquetado para sistemas Windows
95
10.1.2 Generacin de un instalador

Si bien la distribucin de la carpeta ./dist, posiblemente en formato comprimido (.zip, .rar, etc.), es suciente para correr la aplicacin y esta se encuentra optimizada, el usuario Windows est acostumbrado a la utilizacin de instaladores que disponen los archivos en un directorio para tal menester ("windows/programs files" en general), realizan tareas como la registracin de la aplicacin y generan entradas de acceso rpido en el Men de Inicio, por ejemplo. Para realizar un instalador a partir del directorio generado por py2exe se utiliz la aplicacin NSIS (Nullsoft Scriptable Install System) (http://nsis.sourceforge.net/), que es una software open source para la creacin de instaladores Windows.
Figura 10.3: Creando un instalador Windows a partir de un zip con el contenido resultante de py2exe
10.1.3 Compatibilidad
La instalacin de GPEC se ha probado satisfactoriamente en sistemas Windows XP, Windows Vista y Windows 7.
96
10.2 Instalacin en sistemas Linux

Para entornos Linux, el empaquetado y la distribucin se realiza mediante las nombradas Python Distribution Utilities (Distutils) . En trminos generales, es un anlogo al utilitario make muy comn en ujos de desarrollo basadas en lenguaje C o C++, que permite la declaracin de dependencias y la instalacin de un paquete Python, ya sea esta una aplicacin en s, una extensin o un mdulo de funciones auxiliares. La diferencia fundamental con el empaquetado para Windows es que no se distribuye el conjunto de dependencias, sino que estas son simplemente declaradas. El usuario (o el instalador automatizado, como easy_install) son los encargados de asegurar el cumplimiento de esta dependencia, ya sea vericando que est previamente instalada en el sistema o instalandola. Aunque esto genera cierto overhead en primera instancia, porque una dependencia (por ejemplo, Matplotlib) es instalada completamente, esta poltica permite una optimizacin cuando existen dependencias comunes en diversas aplicaciones. En nuestro ejemplo, si dos aplicaciones requieren Matplotlib, utilizan una nica versin instalada en el sistema. Esta coincidencia de dependencias es altamente frencuente en sistemas Linux, heredada de la losofa Unix que se resume en su famoso leitmotif: Write programs that do one thing... and do it well 1 Sin embargo, por falta de masa crtica y tiempo, al momento de la presentacin no se realizaron instaladores ni paquetes especcos para una distribucin Linux, aunque la instalacin mediante el cdigo fuente es trivial, dado que Python no requiere compilacin. Los siguientes comandos son sucientes para la obtencin de la ltima versin de GPEC y sus dependencias:
$ sudo apt-get install python-matplotlib python-matplotlib-data python-numpy python-wxgtk2.8 wine subversion $ svn checkout https://gpec2010.googlecode.com/svn/trunk/src gpec
Y para ejecutarlo, simplemente se invoca el script principal:

$ python gpec/aui.py
10.3 Distribucin y soporte

Dada la gratuidad de GPEC, cada nueva versin se deja disponible automticamente en la seccin de descargas del sitio de desarrollo, http://code.google.com/p/gpec2010/downloads/list y tambin en su sitio ocial http://gpec.efn.uncor.edu Tambin se ha creado un grupo de correo , que intenta nuclear a la comunidad de usuarios e interesados en GPEC. All se remiten novedades del desarrollo, se contestan dudas y se recibe feedback de los usuarios. La direccin del grupo es http://groups.google.com.ar/group/gpecdiscuss
Escribe programas que hagan una cosa... y hazlo bien Ver http://en.wikipedia.org/wiki/Unix_philosophy
10.2. Instalacin en sistemas Linux
97
98
CAPTULO 11
Conclusiones
11.1 Resultados
El desarrollo de este proyecto ha satisfecho los objetivos y requerimientos planteados. El software obtenido constituye una mejora cualitativa y cuantitativa de funcionalidad y facilidad de uso respecto a la versin preexistente. Se consigui una aplicacin multiplataforma a partir de una nica rama de cdigo que ha sido probada en sistemas Windows XP, Windows Vista, Windows 7 de 32 y 64bits y las distribuciones con kernel Linux Ubuntu (32 y 64bits) y Red Hat. Los grcos producidos tienen alta calidad, con herramientas de manipulacin accesibles desde la misma interfaz (barra de herramientas y men contextual) que permiten el control de escala, el deslizamiento, el manejo del historial de visualizacin, ocultacin de curvas, escala logartmica, visualizacin de grilla, etc. La generacin de diagramas 3D constituye una funcionalidad de alta repercusin, sobre todo para la compresin y el estudio introductorio del comportamiento del equilibrio de fases. La naturaleza interactiva (rotacin, superposicin de diagramas) permite complementar y asimilar el conocimiento, tarea compleja basndose en diagramas 2D tpicos de la bibliografa. Como ya se ha mencionado, un aspecto de especial inters fue la mejora en la usabilidad que ha sido estudiada mediante algunas pruebas (por ejemplo, el comportamiento de usuarios con conocimiento del dominio del problema que usan por primera vez la aplicacin, o usuarios que no comprenden el dominio pero logran hacer funcionar el programa intuitivamente). La conclusin es que la interfaz es intuitiva y bien lograda aunque se trate de un aspecto sensible a un proceso de mejora continua. La calidad de la los grcos, exportable en mltiples formatos aptos para la publicacin cientca (por ejemplo EPS (Encapsulated PostScript), incrustable en documentos generados con LaTeX) tambin es una caracterstica superadora y bien recibida por los usuarios, ya que evita el procesamiento grco de capturas de pantalla (con resultados de pobre calidad) o la gracacin de los sets de datos mediante otras herramientas de software.
99
11.2 Observaciones respecto a la tecnologa empleada

La utilizacin de Python como lenguaje para computacin cientca ha sido una prctica en constante crecimiento alrededor del mundo, tanto en ambientes acadmicos como de la industria. Prueba de esto es el xito de la conferencia SciPy: Python for Scientic Computing Conference que durante 2011 tendr su 10 edicin 1 en Austin, Estados Unidos, mientras que en agosto se har la 4 edicin de la versin europa, EuroScipy, en Pars, Francia. La edicin de 2010 convoc a ms de 500 profesionales (ingenieros, matemticos, fsicos, qumicos, bilogos), 47 empresas involucradas y los auspicios destacados de Dell, Microsoft y el gobierno de India. En este ltimo pais, vanguardia mundial en la industria del desarrollo de software y en la calidad de su educacin superior tcnica, en el ao 2009 se ha puesto en marcha un programa denominado FOSSE (Free and Open source Software for Science and Engineering Education) con un presupuesto global de 1000 millones de dlares para que los estudiantes de ciencias e ingenieras usen herramientas open source para todas sus necesidades computacionales, mejorando as la calidad de la enseanza y el aprendizaje 2 . Uno de las tres pilares programticos es el uso de Python para la computacin cientca. Adems, Python ha obtenido el premio a mejor lenguaje de programacin durante 3 ediciones consecutivas (2008-2010) en el programa Readers Choice Awards de la revista especializada Linux Journal 3 Por otra parte, el conjunto de herramientas complementarias (Matplotlib y Numpy) constituyen a esta altura casi un estndar de facto para el software cientco con Python, con probado xito de integracin y cuyas comunidades de desarrolladores y usuarios estn intrnsecamente relacionadas En este contexto de creciente aceptacin, la eleccin de Python y sus complementos constituy un acierto, no slo por los resultados satisfactorios en relacin a los objetivos y tiempos propuestos, sino porque se suma a una corriente de modernizacin tecnolgica de los mbitos cientco-tecnolgicos, en particular en lo relacionado con el desarrollo de software, aportando calidad, facilidad y potencia de prestaciones. Por ltimo, si bien todava no ha podido cuanticarse, la decisin de mantener el proyecto bajo una licencia libre permitir no slo mayor facilidad para que la comunidad de usuarios reporte (y, eventualmente, resuelva) fallos, sino para potenciar sus posibilidades de disfusin, accediendo a circuitos a los que el software privativo (de escala moderada) no accede sin costosas campaas de marketing.
11.3 Problemas detectados

Una de las dicultades detectadas constituy falta de un proceso de refactoring temprano que permitiera llevar la aplicacin a un patrn general de la aplicacin, por ejemplo del ti1 2
Sitio web: http://conference.scipy.org Sitio web: http://fossee.in/ 3 Sitio web: http://www.linuxjournal.com/content/readers-choice-awards-2010
100
Captulo 11. Conclusiones
po Modelo-Vista-Controlador. No obstante, la aplicacin est separada lgica y modulamente segn las distintas incumbencias, lo que vuelve factible esta tarea. Otra dicultad se avisora de cara al futuro del proyecto relacianada con la utilizacin de Pub/Sub. El total desacople (una parte no conoce de la otra) requiere un criterio sistemtico de parte del equipo de desarrollo y una documentacin clara sobre quin, cmo y sobre qu mensajes se acta.
11.4 Tiempo de desarrollo

El tiempo insumido para la concrecin fue mayor que el deseado 4 , pero diversas mtricas dan cuenta que ha sido un desarrollo al menos un 40 % ms rpido que lo estimado restrospectivamente 5 . En este sentido, se concluye que la metodologa y las tecnologas empleadas han dado resultados positivos. Ms an, analizando el historial de revisiones del repositorio, iniciado el 4 de julio de 2010 6 , puede notarse que durante algunas semanas se realizaron muchos avances (inrindose esto, con cierto margen de error, desde la cantidad de commits realizados) mientras que en otras estuvo detenido. Puede concluirse d esto que el ritmo de desarrollo pudo haber sido ms alto y, consecuentemente, haber alcanzado los objetivos propuestos con anterioridad, si hubieran existido condiciones (econmicas, acadmicas, laborales, etc.) para una dedicacin fulltime al proyecto.
11.5 Costo de desarrollo

Segn la herramienta de anlisis de cdigo Ohloh (https://www.ohloh.net) que utiliza el algoritmo COCOMO 7 , el cdigo de GPEC se compone de aproximdamente 6700 lneas de cdigo Python, lo que insume un esfuerzo estimado de 1 programador/ao. Segn un salario internacional estndar para un proyecto de software con esta complejidad y lenguaje, el costo del software (sin su documentacin) se estima en u$s 81,053 considerando una remuneracin internacional estndar de un programador semi-senior 8 . Contemplando la escritura de la documentacin (este reporte), el esfuerzo estimado se eleva a 3 desarrolladores/ao y u$s 151.358 de costo total 9 .
Se considera el proyecto iniciado en el mes de Julio de 2010, aunque la idea se trabaj informalmente desde tiempo antes. Esto suma 9 meses hasta Marzo de 2011. El algoritmo COCOMO predice, en la estimacin ms favorable, un tiempo de desarrollo de 15 meses. 5 Revisin 1 http://code.google.com/p/gpec2010/source/detail?r=1 6 Con cierta perspicacia puede observarse que el autor bautiz el nombre clave del proyecto como GPEC 2010 (tal es el nombre utilizado en Google Code) donde se reeja que la expectativa, no poco audaz, era concluir el trabajo durante dicho ao. 7 COCOMO es un algoritmo de estimacin de costos de software que utiliza una regresin de la evolucin del proyecto. Ver http://en.wikipedia.org/wiki/COCOMO . 8 The average computer programmer salary is around USD 55,000 per year. Fuente http://www.buzzle.com/articles/computer-programmer-salary.html 9 Una correccin no desestimable a este clculo es que se calcula el costo de la documentacin fuente en restructuredText y la generada en HTML de manera automtica con Sphinx, que representa aproximadamente un 23 % del costo total
4
11.4. Tiempo de desarrollo
101
Mediante la herramienta SLOCCount (http://www.dwheeler.com/sloccount/) de David Wheeler se estima un esfuerzo de 14.74 meses y un costo total estimado de $ 162,167, debido a un factor de overhead (relacionado con la complejidad de abstraccin) del 240 %, lo que da pauta de la complejidad global del software.
tin@azulita:~/facu/pi/src$ sloccount --personcost 55000 ./ (...) Totals grouped by language (dominant language first): python: 5627 (99.88 %) xml: 7 (0.12 %) Total Physical Source Lines of Code (SLOC) = Development Effort Estimate, Person-Years (Person-Months) = (Basic COCOMO model, Person-Months = 2.4 * (KSLOC**1.05)) Schedule Estimate, Years (Months) = (Basic COCOMO model, Months = 2.5 * (person-months**0.38)) Estimated Average Number of Developers (Effort/Schedule) = Total Estimated Cost to Develop = (average salary = $55,000/year, overhead = 2.40). SLOCCount, Copyright (C) 2001-2004 David A. Wheeler 5,634 1.23 (14.74) 0.58 (6.95) 2.12 $ 162,167
11.6 Impacto
Si bien la publicacin y difusin de las versiones pblicas de este software se han mantenido como versiones beta manteniendo en paralelo el acceso a descarga de la versin anterior como versin estable, esta nueva versin de GPEC ya ha tenido experiencias de uso. Como se mencion previamente, durante el mes de noviembre de 2010, la ctedra Termodinmica, correspondiente al 4 cuatrimestre de la carrera Ingeniera Qumica de la Facultad de Ciencias Exctas, Fsicas y Naturales (Universidad Nacional de Crdoba), utiliz la nueva versin para su prcticas de laboratorio, con gran aceptacin y buenos resultados por parte de los alumnos. Con vista a la experiencia del corriente ao, la ctedra de la asignatura tiene como plan preparar un artculo sobre la mejora pedaggica de la enseanza de termodinmica asistida con el uso de esta nueva versin de GPEC. Asimismo, este trabajo permiti la publicacin de un poster titulado Una nueva interfaz de 102 Captulo 11. Conclusiones
usuario y mayores prestaciones para el software GPEC, con la rma del desarrollador y los directores Cismondi y Wolfmann, en las conferencias PyCon Argentina 2010 10 y RITeQ 2010
11
Figura 11.1: Poster expuesto en el congreso PyCon Argentina 2010. Fotografa de Elas Andrawos.
11.7 Experiencia de trabajo

El trabajo interdisciplinario que ha involucrado profesionales del rea de la ingeniera en computacin y de la ingeniera qumica ha sido exitoso y abre las puertas a nuevas y ms profundas colaboraciones. Si bien GPEC en s constituye el principal logro, la experiencia de trabajo y la know how adquirido repercute en benecio no slo del autor, sino de las distintas reas, los docentes involucrados y futuros tesistas que se aboquen a un proyecto similar o a la continuacin de este mismo.
10 11
Conferencia Python Argentina, sitio web: http://ar.pycon.org/2010/about/ II Reunin Interdisciplinaria de Tecnologa y Procesos Qumicos. Sitio web: http://riteq.efn.uncor.edu
11.7. Experiencia de trabajo
103
Asimismo, en el mes de enero de 2011 se present un proyecto al programa Crdoba Innovadora, impulsado por una articulacin de Agencia para el Desarrollo Econmico de la ciudad de Crdoba, el Gobierno de la Provincia de Crdoba y la Municipalidad de Crdoba cuyo objeto es el conanciamiento de la implementacin de innovaciones que mejoren productos, procesos, sistemas de organizacin, marketing y/o comercializacin 12 . El proyecto lleva como ttulo Adaptacin, manipulacin y gracacin de datos utilizando el lenguaje de programacin Python, y se trata de un programa de capacitacin para investigadores de IDTQ, basado en la experiencia adquirida con las tecnologas involucradas en este proyecto.
11.8 Lneas de trabajo abiertas

11.8.1 GPEC como aplicacin Web
Con la popularizacin y el incremento de velocidad de los accesos a Internet, en los ltimos aos la computacin en la nube (Cloud Computing) 13 se ha constituido como una tendencia para el desarrollo de software en general, excediendo los dominios de las redes sociales, los juegos y las aplicaciones orientadas a la comunicacin corporativa que dieron su origen. Esta tendencia se acenta dia a dia con nuevos dispositivos que acceden a la red (como smartphones, tablets o netbooks) que sin importar cuanto poder de clculo tengan por s mismos, pueden acceder informacin y solicitar procesamientos a servidores online. Aplicaciones en la nube como Google Docs (http://docs.google.com) virtualmente reemplazan paquetes de software de escritorio para omtica, con la ventaja de independizar al usuario del soporte fsico de la informacin, las actualizaciones del software, y el caractersticas subyacentes de su equipo cliente. Se suman adems las posibilidades multiusuario que brinda la red; por ejemplo, la edicin simultnea de un documento entre distintos usuarios. Intentos ms osados (aunque algo inmaduros) como eyeOS (http://eyeos.info/) intentan constituirse en un reemplazo total del sistema operativo, integrando omtica, almacenamiento de datos, comunicacin, edicin grca, ocio, etc. en un escritorio virtual accesible via web. Llevado al campo del software cientco, donde el aspecto colaborativo es esencial por gnesis, el paradigma tiene especial asidero y de esto da cuenta, por ejemplo, la conferencia Science Online London realizada en 2010 14 cuya pregunta disparadora es Cmo la web est cambiando la ciencia? Entre muchos aspectos considerables para una respuesta, surge como ejemplo aplicado la plataforma Sage Notebook (http://www.sagenb.org/), que brinda una aplicacin online, interactiva, colaborativa y abierta para el desarrollo matemtico. Dado el desarrollo actual, este escenario es tcnicamente viable al corto plazo. Es decir, es posible, sin demasiado trabajo, convertir (o complementar) GPEC como aplicacin web, de manera que el usuario no tenga que bajar ni instalar ningun software en su equipo y pueda generar diagramas directamente online.
12 Al trmino de la presentacin de este reporte la agencia organizadora no ha expedido sobre la aprobacin o no del proyecto. Sitio web: http://adec.org.ar/ 13 El cloud computing es un paradigma que permite ofrecer servicios de computacin a travs de Internet. 14 How is the web changing science?. Sitio web: http://www.scienceonlinelondon.org/
104
Esta posibilidad implica una potencial estrategia de comercializacin, en el marco de lo que se conoce como S AA S (Software as a Service) 15
11.8.2 Importacin y gracacin de datos experimentales

Una de las utilidades de GPEC como entorno de modelado de comportamientos de sistemas termodinmicos es la comparacin de sus resultados con datos experimentales. Para esto se hace necesario (y es factible) la importacin de datos para ser gracados como curvas experimentales.
11.8.3 Versin nativa del backend para Linux

La dependencia con Wine de los programas Fortran que implementan el clculo es una solucin de compromiso que repercute signicativamente en la performance. Pruebas sencillas revelan que los tiempos de ejecucin a travs de este emulador son de al menos un 300 % ms lento que sobre Windows en el mismo equipo. Si bien se trata del orden de segundos, para llevar la arquitectura a un sistema centralizado basado en web, donde se debe dar respuesta potencial a muchos usuarios simultneos, es necesario eliminar este requerimiento y optimizar la comunicacin entre las capas. Nota: Durante Marzo de 2010, el ingeniero qumico Francisco Snchez ha realizado adaptaciones del cdigo fuente Fortran para lograr ejecutables nativos para plataforma Linux.
11.8.4 Nuevas funcionalidades

Durante el transcurso del proyecto surgieron muchas ideas de mejoras posibles. Se listan a continuacin algunas de ellas: Consola interactiva que permita la manipulacin avanzada de grcos y vectores de datos. Esta caracterstica ha sido parcialemente implementada. Mtricas automticas de los diagramas que indiquen rangos interfaciales y puntos crticos de manera ms precisa Generacin de videos de animacin a partir de una rotacin paso a paso de un diagrama 3D y la correspondiente captura (exportacin). Congurabilidad de los parmetros de visualizacin, que permitan de manera no programtica cambiar colores, espesores, estilos y dems opciones de las curvas trazadas. Esto permitira, por ejemplo, optimizar un diagrama para la presentacin en escala de grises, donde el contraste de distintos colores muchas veces se vuelve indistinguible. Mejora en la interoperabilidad y exportacin de datos. Soporte de impresin
15
Ver http://en.wikipedia.org/wiki/Software_as_a_service
11.8. Lneas de trabajo abiertas
105
11.8.5 Ampliacin del conjunto de pruebas unitarias

Si bien se han probado puntos crticos susceptibles a vulnerabilidad, es necesario lograr una cobertura de prueba total del sistema, no slo en el gestor de la API sino en la interfaz de usuario. Esto es, generar prubas que lancen eventos programticamente simulando las acciones del usuario, y validar los resultados. El libro [NR-RD2006] trata y ejemplica estas tareas.
11.8.6 Mejora y refactorizacin a patrones de diseo

Como se ha visto, GPEC se vale de diversos patrones de diseo de software y especialmente del patrn Publisher/Subscriber. No obstante, para garantizar aspectos como mantenibilidad, escalabilidad y seguridad del software sera deseable realizar un proceso de refactorizacin a patrones ([JK1999]), en particular en lo concerniente a una arquitectura de separacin ms acabado entre lgica e interfaz.
106
APNDICE A
Ejemplos de diagramas
Este apndice muestra algunos ejemplos de diagramas realizados con la aplicacin
Figura A.1: Visualizacin 3-D de un diagrama global P-T- con superposicin de curvas Pxy y Txy. Los grcos 3D se pueden rotar a la perspectiva deseada.
107
Figura A.2: Visualizacin 3-D de un diagrama global P-T-z (comportamiento tipo I) y superposicin de diagramas tipo Pxy para distintas temperaturas, Txy para distintas presiones e isopletas para distintas composiciones.
Figura A.3: Superposicin de tres diagramas globales que permiten observar el efecto del parmetro de interaccin k12. La imgen fue exportada desde GPEC. 108 Apndice A. Ejemplos de diagramas
Figura A.4: Visualizacin 3-D de un diagrama global P-T-z con superposicin de curvas Pxy, Txy e isopletas.
109
110
Apndice A. Ejemplos de diagramas
Bibliografa
[SM-VN-AG2000] Smith, JM - Van Ness, HC - Abbott, MM (2000), Introduccin a la termodinmica en ingeniera qumica - 6ta Edicin, McGraw-Hill [UNC1] Universidad Nacional de Crdoba, Estatuto de la UNC - Misin de la Universidad: http://www.unc.edu.ar/institucional/organizacion/estatutos/mision [FSFa] Free Software Foundation, La http://www.gnu.org/philosophy/free-sw.es.html denicin de Software libre,
[ARR2003] Rey Roque, Antonio (2003), Experiencias en el trabajo Interdisciplinario desde una Disciplina Bsica, Departamento de Matemticas, Facultad de Informtica, Universidad de Cienfuegos Carlos Rafael Rodrguez, Cuba [JMiH2005] Mas i Hernndez, Jordi (2005), Software Libre. Tcnicamente viable, econmicamente sostenible y socialmente justo, infonomia.com (Ed.), Barcelona [ER1997] Raymond, Eric S (1997), The Cathedral and the Bazaar, Open Source Software Foundation, Traduccin al espaol del Proyecto Lucas, http://es.tldp.org/Otros/catedralbazar/cathedral-es-paper-00.html [RMS2004] Stallman, Richard M (2004), Libre pero encadenado. La trampa del Java., FSF (Free Software Foundation), http://www.gnu.org/philosophy/java-trap.es.html [DG2009] Gezelter, Dan (2009), What, http://www.openscience.org/blog/?p=269 exactly, is Open Science?,
[CLD03] Challet, D - Le Du, Y (2003), Microscopic model of software bug dynamics: closed source versus open source, International Journal of Reliability, Quality and Safety Engineering [AG-MANIF] Varios autores (2001), Manifesto for Agile Software Development, http://agilemanifesto.org/
111
[Sommerville2004] Sommerville, Ian (2004) Software Enginnering, 7th edition, Pretince Hall Traduccin al espaol por el Departamento de Ciencias de la Computacin e Inteligencia Articial de la Universidad de Alicante (2005). [Quatrani2010] Quatrani, Terry (2010) The Truth About Agile Modeling. Cita extrada de http://agilescout.com/agile-modeling-and-uml/ [Martin2006] Martin, Robert (2006) Agile Principles, Patterns, and Practices in C#, Prentice Hall. Cita extrada de http://stackoverow.com/questions/61487/do-you-use-uml-in-agiledevelopment-practices [Stevens2006] Steven, Alan (2006) UML Sucks (Really!), http://halanstevens.com/uml-sucksreally/ [GvR1998] van Rossum, Guido (1998), Glue it all together with Python, Workshop on Compositional Software Architecture in Monterey, http://www.python.org/doc/essays/omg-darpamcc-position.html [AM-IG2003] Marzal, Andrs - Gracia, Isabel (2003), Introduccin a la programacin con Python, Departamento de Lenguajes y Sistemas Informticos, Universitat Jaume I, Castell de la Plana [ZIADE2008] Ziad, Tarek (2008), Expert Python programming, Pack Publishing [MA2010] Alchin, Marty (2010), Pro Python, Apress [JH-FP] Hunter, John D. - Prez, Fernando, (n/d) Practical Scientic Computing in Python, [TUT-PSF] van Rossum, Guido (2010), The Python Tutorial v2.7, Python Software Foundation, http://docs.python.org/tutorial/ . Existe una traduccin al espaol realizada por la comunidad Python Argentina en http://tutorialpython.com.ar [MP2001] Pilgrim, Mark (2001), Dive into Python, publicado bajo los trminos de GNU Free Documentation License, http://diveintopython.org/. Existe una traduccin al espaol disponible en http://www.grulic.org/almacen/diveintopython-5.4-es/ [WIKIPEDIA1] Contribuidores varios, Polymorphism in object-oriented programming, Wikipedia, The Free Encyclopedia, visto el 16 de agosto de 2010, http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming [HPL2004] Langtangen, Hans P (2004), Python Scripting for Computational Science, Simula Research Laboratory and Department of Informatics University of Oslo, Oslo [PEP8] van Rossum, Guido - Warsaw, Barry (2001), Python Enhancement Proposals (PEP) #8: Style Guide for Python Code, Python Software Foundation, http://www.python.org/dev/peps/pep-0008/ [PEP20] Peters, Tim (2004) Python Enhancement Proposals (PEP) #20: The Zen of Python, Python Software Foundation, http://www.python.org/dev/peps/pep-0020/ [NumPy-UG] Scipy community, NumPy User Guide, http://docs.scipy.org/doc/numpy [TO2006] Oliphant, Travis http://www.trelgol.com (2006) Guide to NumPy, Trelgol Publishing,
112
Bibliografa
[MPLDOC] Hunter, J - Dale, D - Droettboom, M (2010), Matplotlib documentation v1.0.0, http://matplotlib.sourceforge.net/contents.html [NR-RD2006] Rappin, Noel - Dunn, Robin (2006), wxPython in Action, Manning Publications [ST2009] Tosi, Sandro (2009) Matplotlib for Python Developers, Build remarkable publication quality plots the easy way, Pack Publishing [LL-RJ2003] Lindstrom, Lowell - Jeffries, Ron (2003) Extreme Programming and Agile Software Development Methodologies, http://xprogramming.com [GR-STE2005] Greene, Jeniffer - Steelman, Andrew (2005) Applied Software Project Management, OReilly Associates [vdLaar2002] van de Laar, F. (2002). Publish/Subscribe as architectural style for component interaction (Maters thesis), Phillips Research Laboratories [Spolsky2001] Spolsky, Joel (2001). User Interface Design for Programmers, Apress [Vera1994] Vera Lujn, A. (1994), Fundamentos del anlisis sintctico, Universidad de Murcia [Zulberti2010] Zulberti, Toms (2010), Introduccin a Unit Testing con Python, Revista PET: Python Entre Todos* N 1 - Agosto 2010, Comunidad de Usuarios Python Argentina. Disponible en http://revista.python.org.ar/1/html/unittest.html [Nielsen2000] Nielsen, Jakob (2000) Why You Only Need to Test with 5 Users, http://www.useit.com/alertbox/20000319.html [Nielsen2009] Nielsen, Jacob (2009) 230 Tips and Tricks for Better Usability Testing, Nielsen Norman Group [JK1999] Kerievsky, Joshua (1999) Refactoring to Patterns, Addison-Wesley
Bibliografa
113
114
Bibliografa
APNDICE B
Especicacin de la interfaz de comunicacin
Esta documentacin especica la interfaz de archivos de entrada y salida para el conjunto de programas de clculo que componen GPEC. Se ha realizado a travs de un proceso de ingeniera inversa, ya que se careca de documentacin fehaciente.
B.1 Tabla de incidencia

Entrada CONPARIN.DAT CONPARIN.DAT GPECIN.DAT GPECIN.DAT + GPECOUT.DAT + TFORPXY.dat GPECIN.DAT + GPECOUT.DAT + PFORTXY.dat GPECIN.DAT + GPECOUT.DAT + ZforIsop.dat GPECIN.DAT + FUGIN.DAT GPECIN.DAT + IsoXTin.DAT twophin.DAT2 twophin.DAT2 Ejecutable ModelsParam PCSAFT GPEC PxyGPEC TxyGPEC IsoplethGPEC FUGi IsoXT PhPxy PhTxy Salida CONPAROUT.DAT CONPAROUT.DAT GPECOUT.DAT PXYOUT.DAT TXYOUT.DAT ISOPOUT.DAT FUGOUT.DAT IsoXTout.DAT PXYOUT.DAT TXYOUT.DAT
B.1.1 CONPARIN.DAT
Es el archivo de entrada para el clculo de parmetros especcos para los modelos en funcin de las constantes de cada compuesto, o bien, en sentido contrario, ajustar las constantes en
115
funcin de parmetros del modelo denido por el usuario. Esta bidireccionalidad del clculo se especica mediante el parametro SENTIDO. Nota: el archivo se encuentra en realidad en ./INOUTS/CONPARIN.DAT Formato General: SENTIDO MODELO PARAM1 PARAM2 PARAM3 [PARAM4] ID 0 SENTIDO 1 ID 1 2 3 4 6 Descripcin Calcula parmetros especcos del modelo en funcin de las constantes del compuesto Calcula constantes del compuesto en funcin de los parmetros del modelo Modelo Soave-Redlich-Kwong Peng-Robinson RK-PR PC-SAFT SPHCT
MODELO
B.1.2 Modo para calcular parmetros del modelo

Este modo se dene con SENTIDO 0. Se denen las variables del compuesto. Modelos 1, 2, 3: 0 MODELO TC PC OM VC Para los modelos 4 y 6 el formato es el siguiente:
0 MODELO TC PC OM
.. attention:: El ejecutable a invocar para el clculo en los modelos 4 o 6 es PCSAFT
Detalle: Parmetro TCeos PCeos VCeos OM Descripcin Temperatura Presin Volumen Factor acentrico Unidad K Bar l/mol
Todos los parmetros son editables en el formulario excepto VCeos. Para RK-PR el valor s es editable y est asociado a un factor denominado Critical Volume Ratio Model/Experimental o VCrat que se ja por omisin a 1.168. V Ceos = V Cmodel V Crat 116 Apndice B. Especicacin de la interfaz de comunicacin
Para el modelo RK-PR se permite editar esta proporcin. Si el usuario dene VCeos, se actualiza el VCrat y viceversa.
B.1.3 Modo para calcular variables del compuesto

Cuando SENTIDO es 1 el formato depende del modelo 1 Soave-Redlich-Kwong 1 1 ac b m Detalle: Parmetro ac b m Descripcin Unidad barm^6kmol^2 l/mol
2 Peng-Robinson Idem Soave-Redlich-Kwong 3 RK-PR

1 3 ac b del1 k
Detalle: Parmetro ac b del1 k 4 PC-SAFT

1 4 eps/k ro m
Descripcin
Unidad barm^6kmol^2 l/mol
Detalle: Parmetro eps/k ro m 6 SPHCT

1 T* 6 V* c
Descripcin
Unidad K
B.1. Tabla de incidencia
117
B.2 CONPAROUT.DAT
Es el archivo de salida para el clculo de parmetros y constantes. El formato es el mismo independientemente del sentido de clculo, teniendo la primer lnea las variables de estado del compuesto, y en la segunda, los parmetros propios del modelo. Formato General: VAR1 VAR2 VAR3 VAR4 PARM1 PARAM2 PARAM3 [...] Detalle: Para Soave-Redlich-Kwong (id 1) y Peng-Robinson (id 2):
TC ac PC b VC m OM
Para RK-PR (id 3):

TC ac PC b VC del1 OM k
Para PC-SAFT (id 4):

TC PC eps/k ro VC m OM
Para SPHCT (id 6): TC PC VC OM T* V* c
B.3 GPECIN.DAT
Se trata del archivo de entrada de parmetros para el clculo del diagrama global. Formato General:
MODELO NCOMB NTDEP NOMBRE_COMP1 CONST1 CONST2 PARAM1 PARAM2 NOMBRE_COMP2 CONST1 CONST2 PARAM1 PARAM2 K12 L12 MAX_P
CONST3 PARAM3 CONST3 PARAM3
[...] [...] [...] [...]
Ejemplo:
118
Apndice B. Especicacin de la interfaz de comunicacin
1 0 0 METHANE 190.56 45.99 0.0115 0.114837 2.33338 0.029849 0.498078 ETHANOL 514 61.37 0.6436 0.232124 12.722 0.060334 1.420538 0.1000 0.0000 2000
MODELO ID de Modelos NCOMB Regla de combinacin ID 0 1 Descripcin van Der Waals Lorentz-Berthelot
No todos los modelos pueden usar cualquier regla de combinacin. En particular, PC-SAFT y SPHCT exigen que la regla sea Lorentz-Berthelot. NTDEP dependencia con T para los parmetros de interaccin, on/off ..todo:: ver qu corno es esto. NOMBRE_COMP Nombre del compuesto. Se puede ignorar. CONST Constantes del compuesto. Para los modelos 1, 2 y 6 los parmetros son los siguientes:
TC PC OM VC
Para el modelo 4 se agrega un parmetro ms:

TC PC OM VC VCrat
Detalle: Parmetro TC PC OM VC VCrat Descripcin Temperatura Presin Volumen Volumen Unidad K Bar l/mol l/mol
PARAM Los parmetros especcos previamente calculados en funcin del modelo elegido. Ver CONPAROUT.DAT Para los modelos 1 o 2 los parmetros tienen el siguiente formato:
ac b m
Detalle:
B.3. GPECIN.DAT
119
Software para la gracacin de diagramas termodinmicos Parmetro ac b m Descripcin Unidad barm^6kmol^2 l/mol
Para el modelo 3 (RK-PR):

ac b del1 k
Detalle: Parmetro ac b del1 k Descripcin Unidad barm^6kmol^2 l/mol
Para el modelo 4 (PC-SAFT):

eps/k ro m
Detalle: Parmetro eps/k ro m Descripcin Unidad K
Para el modelo 6 (SPHCT)

T* V* c s q
Detalle: Parmetro T* V* Descripcin Temperatura Volumen Unidad K .
K12 Parmetro de interaccin binario L12 Parmetro de interaccin binario MAX_P Mxima presin para lquidos. Se especica en bar.
B.4 GPECOUT.DAT
Es el archivo de salida de GPEC. Tiene una cabecera, donde especica a nes descriptivos los parmetros que se utilizaron para realizar el clculo, y diversas tablas de valores tabulados, cada una de las cuales representan una curva en el espacio n-dimensional. Tomando 2 de estas columnas de valores se obtienen las distintas curvas a gracar.
120
B.4.1 Cabecera
Para el analisis sintctico, se puede ignorar la cabecera del archivo. Sin embargo, para los nes descriptivos se incluye un ejemplo:
METHANE Tc= 190.5600 Pc = Zc= 0.2863 Zcrat= ac= 2.3270 b = ETHANOL Tc= 514.0000 Pc = Zc= 0.2412 Zcrat= ac= 14.5350 b = 45.9900 Vc = 1.1680 Zceos= 0.0300 del1= 61.3700 Vc = 1.1680 Zceos= 0.0482 del1= 0.0986 OM = 0.0115 0.3344 Vceos= 0.1152 0.9244 k = 1.5086 0.1680 OM = 0.6436 0.2817 Vceos= 0.1962 3.8196 k = 3.1328
Tc, Pc and Vc are given in K, bar and L/mol respectively K12 = 0.000000000000000E+000
LIJ MATRIX METHANE ETHANOL 0.00000 Combining rules: 0: Classical or van der Waals
Esta cabecera puede cambiar ligeramente en funcin del modelo con el que se calcul.
B.4.2 Datos tabulados

La estructura general de una tabla de datos tabulados tiene la siguiente estructura:
Var1(Un) TIPO dato1.1 dato2.1 ... [Comment] Var2(Un) dato1.2 dato2.2 Var3(Un) dato1.3 dato3.3 [...] [...] [...] ? ? ? ?
Var(Un) Describe explicitamente la variable/constante que representa esa columna. Entra parntesis especica la unidad de medida. Tipo VAP CRI CEP LLV Descripcin Vapor Curva crtica Critical End Point Liquido liquido vapor Columnas signicativas 4 5 6 10
TIPO
Las columnas signicativas son las que deben leerse ya que aportan datos necesarios para la gracacin. Las columnas restantes representan detalles
B.4. GPECOUT.DAT
121
del clculo interno (cantidad de iteraciones, precisin) pero sern ignoradas para los nes de gracacin. El signicado de las las columnas para cada tipo puede verse aqui: Tipo VAP CRI CEP LLV Columnas T(K) Pv(bar) rhoL rhoV T(K) P(bar) d(mol/L) x(1) 1-x(1) T(K) P(bar) X(1) XL1(1) dc(mol/L) dL(mol/L) T(K) P(bar) XL1 XL2 Y(1) Y(2) X2L2 d1(mol/L) d2(mol/L) dV(mol/L)
Las tablas de datos tabulados pueden tener cualquier extensin y terminan nicamente por una lnea en blanco. Tambin pueden existir comentarios luego de la nalizacin de una tabla tabulada. Por ejemplo:
... 166.399 0.1241E-007 165.074 0.9122E-008 164.020 0.7117E-008 19.8163 0.8967E-009 19.8275 0.6646E-009 19.8364 0.5219E-009 1 1 1 3 3 3
Predicted type of phase behaviour is indicated at the end of this file
B.4.3 Pie
Al igual que la cabecera, el nal del archivo aporta informacin extra. Por ejemplo:
Type of phase behaviour predicted by the model for this system 3 Total number of Azeotropic End Points found: 0 Pure Azeotropic End Points found: Critical Azeotropic End Points found: Heterogeneous Azeotropic End Points found: 0 0 0
B.5 TFORPXY.dat
TFORPXY.dat es el tercer archivo de entrada que utiliza PxyGPEC para calcular diagramas Presin-Composicin a una temperatura constante dada. Este archivo simplemente dene el valor de temperatura que el usuario puede ingresar, previo al clculo:
122
TEMPERATURA
:TEMPERATURA: Valor de temperatura en K definido por el usuario, dentro del ran de valores aceptados por el sistema. El rango aceptado lo define el mximo y el mnimo de temperatura encontrado en los bloques de datos tabulados LLV.
B.6 PXYOUT.DAT
Es el archivo de salida para el diagrama Presin-Composicin (diagrama isotermico). Tiene una estructura de datos tabulados como sigue:
T = TEMPERATURA K P Pxy p.1 p.2 (...) p.n X(1) x1.1 x1.2 x1.n Y(1) y1.1 y1.2 y1.n Y(2) y2.1 y2.2 y2.n X(2) x2.1 x2.2 x2.n dX(mol/L) dY(mol/L) [...] dX.1 dX.2 dX.n dY.1 dY.2 dY.n [...] [...] [...]
Tiene 7 columnas signicativas.
B.7 PFORTXY.DAT
Anlogo a TFORPXY.dat para el diagrama de presin constante, este archivo indica el valor de presin denida por el usuario. PRESION PRESION Valor de presin en Bar denido por el usuario, dentro del rango de valores aceptados por el sistema.
B.8 TXYOUT.DAT
Datos tabulados de salida para diagramas isobricos. Tiene la misma estructura que PXYOUT.DAT pero el parmetro constante es la temperatura y la primer columna de datos tabulados es presin:
P = PRESION bar T Txy t.1 t.2 X(1) x1.1 x1.2 Y(1) y1.1 y1.2 Y(2) y2.1 y2.2 X(2) x2.1 x2.2 dX(mol/L) dY(mol/L) [...] dX.1 dX.2 dY.1 dY.2 [...] [...]
B.6. PXYOUT.DAT
123
(...) t.n
x1.n
y1.n
y2.n
x2.n
dX.n
dY.n
[...]
Tiene 7 columnas signicativas.
B.9 ZforIsop.dat
Es un archivo de entrada para IsoplethGPEC que realiza los cmputos para obtener un set de datos para una proporcin del compuesto 1 constante, que dene el usuario. Nota: IsoplethGPEC requiere, adems de este archivo, que GPECIN.DAT y GPECOUT.DAT hayan sido generados. Es similar a PFORTXY.DAT y TFORPXY.dat pero dene un parmetro z adimensional que representa la fraccin de compuesto:
Z :Z: Fraccin de compuesto 1 definida por el usuario.
B.10 ISOPOUT.DAT
Archivo de salida para isopletas (Presin-Temperatura en composicin constante). Tiene la siguiente estructura:
NCRI= CRI T tcri1.1 (...) z1 = y1 = Z T ISO t.1 t.2 (...) t.n T LLV t_llv.1 t_llv.2 P(bar) p.1 p.2 p.n X(1) x1.1 x1.2 x1.n P(bar) p_llv.1 p_llv.2 X(2) x2.1 x2.2 x2.n dX(mol/L) dX.1 dX.1 dX.n dY(mol/L) NITER dY.1 dY.1 dY.n [...] [...] [...] N_L_CRITICAS P(bar) pcri1.1
124
(...) t_llv.n
p_llv.n
Detalle: N_L_CRITICAS Indica el nmero de lneas/puntos crticos, o lo que es lo mismo la cantidad de bloque CRI que se esperan. Z es el valor adimensional que indica la proporcin del compuesto 1 en el sistema. El bloque de datos tabulados ISO tiene 6 cifras signicativas.
B.11 FUGIN.DAT
Archivo de entrada para FUGi que se utiliza para realizar un diagrama Fugacidad-Composicin para una temperatura y una presin dadas. La estructura del archivo es la siguiente:
TEMPERATURA PRESION PASO_COMP X1_min X1_max
Detalle: TEMPERATURA Temperatura en K especicada por el usuario. PRESION Presin en bar especicada por el usuario. PASO_COMP Coeciente de paso de composicin. (determina la resolucin) X1_min Mnimo del dominio (composicin del compuesto 1) X1_max Mximo del dominio (composicin del compuesto 1)
B.12 FUGOUT.DAT
El archivo de salida de datos para Fugacidad-Composicin producido por FUGi. Tiene una estructura similar a GPECOUT.DAT y en particular una cabecera y un bloque de datos tabulados que tiene la siguiente estructura:
T(K) P(bar) TEMPERATURA PRESION FUG x.min f1(x.min) f2(x.min) (...) x.n f1(x.n) f2(x.n) (...) x.max f1(x.max) f2(x.max)
Detalle:
B.11. FUGIN.DAT
125
TEMPERATURA Temperatura en K especicada por el usuario. PRESION Presin en bar especicada por el usuario. Las tres columnas de datos son signicativas.
B.13 IsoXTin.DAT
Archivo de entrada para IsoXT que se utiliza para realizar un diagrama Presin-densidad para temperatura y composicin constante. La estructura del archivo es la siguiente:
TEMPERATURA PROPORCION RHO_min RHO_max PASO_DENS
Detalle: TEMPERATURA Temperatura en K especicada por el usuario. PROPORCION Proporcin (entre 0 y 1, adimensional) del compuesto 1, especicada por el usuario. Rho_min Mnimo del dominio (densidad) en mol/l Rho_min Mnimo del dominio (densidad) en mol/l PASO_DENS Coeciente de paso de densidad. (determina la resolucin)
B.14 IsoXTout.DAT
Archivo de salida similar a FUGOUT.DAT con una cabecera con la siguiente estructura:
T (K) x1 TEMPERATURA PROPORCION rho(mol/L) rho.min (...) rho.n (...) rho.max P(bar) p(rho_min) p(rho_n) rho.max x2 1-PROPORCION
Detalle: TEMPERATURA Temperatura en K especicada por el usuario. PROPORCION Proporcin (entre 0 y 1, adimensional) del compuesto 1 Notar que el bloque de datos no tiene un identicador de tres letras previo a las columnas de datos.
126
APNDICE C
Glosario
C.1 Qumica y termodinmica

diagrama de fase Grco utilizado para mostrar las condiciones en las que distintas fases de un sistema pueden ocurrir en equilibrio. ecuacin de estado EOS (Equation of State) es la relacin entre variables de estado que describen el estado de la materia bajo ciertas condiciones fsicas y a partir de la cual pueden derivarse distintas propiedades termodinmicas. EoS ecuacin de estado estado de agregacin Es el estado en que se presenta en la naturaleza una sustancia; dicho estado puede ser slido, lquido, gaseoso, plasmtico, supercrtico. fase En termodinmica y qumica, se denomina fase a cada una de las partes macroscpicas de una sistema qumica con propiedades fsicas homogneas. Suele usarse como sinnimo de estado de agregacin sin exactitud ya que pueden existir fases distintas en el mismo estado de agregacin (por ejemplo, el diamante y el grato son distintas fases de carbono, y ambas se encuentran en estado slido). isopleta Se denomina isopleta (tambin llamada isolnea o isograma) a la lnea que une los puntos en los que una cierta magnitud es constante, en un mapa o diagrama. En los diagramas de fase reere a las curvas para proporcin de composicin constante. mezcla Es un sistema material compuesto de dos o ms sustancias no combinadas qumicamente. En una mezcla no ocurre una reaccin qumica y cada uno de sus componentes mantiene su identidad y propiedades qumicas, que pueden separarse mediante mtodos fsicos como destilacin, disolucin, separacin magntica, ltracin, etc. propiedades intensivas Son aquellas propiedades que no dependen de la cantidad de sustancia o del tamao de un sistema, por lo que su valor permanece inalterable al subdividir el sistema. Muchas magnitudes extensivas, como el volumen, la cantidad de calor o el peso, pueden convertirse en intensivas dividindolas por la cantidad de sustancia, la masa o el volumen de la muestra; resultando en valores por unidad de sustancia. sistema Ver mezcla 127
sistema binario Un sistema binario es una mezcla de dos sustancias. sustancia Toda porcin de materia que comparte determinadas propiedades intensivas. sustancia pura Sustancia que no puede separarse en otras sustancias por ningn medio fsico (como calentamiento o un campo magntico). termodinmica Rama de la sicoqumica que estudia la conversin de energa entre calor y trabajo mecnico, y subsecuentemente las variables macroscopicas como temperatura, presin y volumen. El equilibrio de fases es la parte de la termodinmica ms estudiada en la Ingeniera Qumica por su importancia en procesos de separacin.
C.2 Computacin
ambiente de desarrollo Es el conjunto de lenguajes de programacin, bibliotecas, utilitarios y herramientas instaladas y debidamente conguradas en un equipo, que es necesario para el desarrollo informtico. Cuando todo este conjunto est integrado en una sla aplicacin se lo denomina IDE (I NTEGRATED D EVELOPMENT E NVIROMENT ). API Una interfaz de programacin de aplicaciones o API es el conjunto de funciones y procedimientos (o mtodos, en la programacin orientada a objetos) que representan una interfaz de comunicacin entre componentes de software. Se trata del conjunto de llamadas a ciertas bibliotecas que ofrecen acceso a ciertos servicios y constituye un mtodo para conseguir abstraccin en la programacin, generalmente (aunque no necesariamente) entre los niveles o capas inferiores y los superiores del software. arreglo Estructura de datos en la que a cada elemento se le asigna un ndice nico. Su representacin matemtica es una matriz Back end Ver Front end backport Backporting es la accin de aplicar cierta modicacin de un software a una versin anterior para la cual no estuvo originalmente creada. cluster El trmino cluster se aplica a los conjuntos o conglomerados de computadoras construidos mediante la utilizacin de componentes de hardware comunes y que se comportan como si fuesen una nica computadora. Es la arquitectura de supercomputadores ms utilizada en la actualidad. computacin cientca Es el campo de estudio relacionado con la construccin de modelos matemticos y mtodos numricos para resolver problemas cientcos, de ciencias sociales y problemas de ingeniera. Tpicamente es la aplicacin de modelado numrico y otras formas de clculo de problemas en varias disciplinas cientcas. decorator Es un patrn de diseo de software que permite agregar dinmicamente (extender, decorar) una funcionalidad inexistente en la denicin de un objeto. Ver Tambin: wrapper Front end El front end es la parte del software que interacta con el o los usuarios y el backend es la parte que procesa la entrada desde el front end. La separacin del sistema en 128 Apndice C. Glosario
front ends y back ends es un tipo de abstraccin que ayuda a mantener las diferentes partes del sistema separadas. La idea general es que el front end sea el responsable de recolectar los datos de entrada del usuario, que pueden ser de muchas y variadas formas, y procesarlas de una manera conforme a la especicacin que el back-end pueda usar. La conexin del front ends y el back-end es un tipo de interfaz FUD del ingls, Fear, Uncertainty and Doubt, en espaol miedo, incertidumbre y duda es una expresin con la que se calica a una determinada estrategia comercial consistente en diseminar informacin negativa, vaga o sesgada con el objeto de perjudicar a un competidor. GNU/Linux Combinacin del ncleo o kernel libre Linux, que es usado con herramientas de sistema GNU para congurar un sistema operativo completo y multipropsito. Su desarrollo es uno de los ejemplos ms prominentes de software libre GUI La interfaz grca de usuario o GUI (del ingls, Graphical User Interface) es un programa informtico que acta de interfaz de usuario, utilizando un conjunto de imgenes y objetos grcos para representar la informacin y acciones disponibles en la interfaz Ver Tambin: layout hacker Persona que disfruta aprendiendo detalles de los sistemas (informticos, de comunicaciones u otro tipo), y cmo extender sus capacidades, con espritu ldico, curioso y solidario, asumindolo como el reto intelectual de superar o rodear las limitaciones de forma creativa. Ver Tambin: What is a Hacker?, Brian Harvey, http://www.cs.berkeley.edu/~bh/hacker.html University of California, Berkeley,
herencia En OOP la herencia es el mecanismo mediante el cual una clase se basa en las propiedades y comportamientos de otra ya denida, pudiendo utilizarlas o redenirlas. Es el mecanismo fundamental para implementar la reutilizacin y extensibilidad del software. Ver polimorsmo. ingeniera inversa Es el conjunto de tareas destinadas a obtener las especicaciones de un sistema de informacin partiendo del propio sistema. Es una actividad tpica del mantenimiento de equipos lgicos, cuando no existen las especicaciones del diseo del equipo a mantener. layout Es la disposicin dada a los elementos o componentes en un determinado espacio middleware El middleware es un software de conectividad entre otros componentes de software. Estrictamente reere al mbito del software distribuido, pero el concepto suele extenderse a cualquier tipo de software. OOP La programacin orientada a objetos (del ingls, Object Oriented Programming) es un paradigma de programacin que usa el modelado de objetos y sus interacciones para disear aplicaciones. Involucra tcnicas como la herencia, el polimorsmo, la abstraccin, etc.
C.2. Computacin
129
polimorsmo Se reere a la posibilidad de denir clases diferentes que tienen mtodos o atributos denominados de forma idntica, pero que se comportan de manera distinta. pseudocdigo Descripcin de alto nivel de un algoritmo que emplea una mezcla de lenguaje natural con algunas convenciones sintcticas propias de lenguajes de programacin, como asignaciones, ciclos y condicionales. Es utilizado para describir algoritmos en libros y publicaciones cientcas, y como producto intermedio durante el desarrollo de un algoritmo. singleton Es un patrn de diseo que restringe y garantiza la creacin de objetos pertenecientes a una clase o el valor de un tipo a un nico objeto. Es una forma de reemplazo de las variables globales de la programacin procedural en la programacin orientada a objetos. software cerrado Forma poco precisa de denominar al software privativo Software Libre El software es libre si garantiza las siguientes libertades al usuario: 0. la libertad de usar el programa, con cualquier propsito. 1. la libertad de estudiar cmo funciona el programa y modicarlo, adaptndolo a sus necesidades. 2. la libertad de distribuir copias del programa, con lo cual puedes ayudar a su prjimo. 3. la libertad de mejorar el programa y hacer pblicas esas mejoras a los dems, de modo que toda la comunidad se benecie. Las libertades 1 y 3 requieren acceso al cdigo fuente porque estudiar y modicar software sin su cdigo fu ente es muy poco viable. Ntese que no se hace referencia a gratuidad o no del software, confusin frecuente debido a que en ingles el trmino free (de Free Software) signica libre o gratis en distintas asepciones. Ver Tambin: Denicin de sw.es.html) Software Libre (http://www.gnu.org/philosophy/free-
software privativo El software privativo (tambin llamado propietario, de cdigo cerrado o software no libre) es cualquier programa informtico en el que el usuario nal tiene limitaciones para usarlo, modicarlo o redistribuirlo (con o sin modicaciones), o cuyo cdigo fuente no est disponible o el acceso a ste se encuentra restringido por un acuerdo de licencia, o por tecnologa anticopia. UML Lenguaje Unicado de Modelado (del ingls, Unied Modeling Language) es el lenguaje de modelado de sistemas de software ms conocido que permite su especicacin, visualizacin, construccin y documentacin usabilidad Es la facilidad con que las personas pueden utilizar una herramienta particular En el mbito del software, el estudioso del tema Jackob Nielsen deni la usabilidad como el atributo de calidad que mide lo fciles que son de usar las interfaces. El concepto de usabilidad es abarcativo de la ergonoma y la intuitividad.
130
Apndice C. Glosario
wrapper Un wrapper es un patrn de diseo (tambin llamado adapter) que transforma una interfaz en otra, de tal modo que una clase que no pudiera utilizar la primera, haga uso de ella a travs de la segunda. Son muy comunes en la adaptacin de bibliotecas desarrolladas en un lenguaje de programacin distinto al que se la desea utilizar.
C.2. Computacin
131
132
Apndice C. Glosario
ndice
A
ambiente de desarrollo, 128 API, 128 arreglo, 128
herencia, 129
I
ingeniera inversa, 129 interpretado, 34 isopleta, 127
B
Back end, 128 backport, 128
L
layout, 129
C
cluster, 128 componentes, 50 computacin cientca, 128
M
mezcla, 127 middleware, 129 multiparadigma, 34 multiplataforma, 34
D
decorator, 128 Diagrama conceptual, 49 diagrama de fase, 127
O
OOP, 129
E
ecuacin de estado, 127 EoS, 127 estado de agregacin, 127
P
polimorsmo, 130 propiedades intensivas, 127 proyeccin ortogonal, 6 pseudocdigo, 130
F
fase, 127 Front end, 128 FUD, 129
S
setUp() (test_apimanager.TestApiManager mtodo), 89 singleton, 130 sistema, 127 sistema binario, 128 software cerrado, 130 Software Libre, 130 software privativo, 130 sustancia, 128 133
G
GNU/Linux, 129 GUI, 129
H
hacker, 129
sustancia pura, 128
T
termodinmica, 128 test_gpecout_1() (test_apimanager.TestApiManager mtodo), 89 test_read_conpaout_1() (test_apimanager.TestApiManager mtodo), 89 test_write_conparin_1() (test_apimanager.TestApiManager mtodo), 89 test_write_conparin_2() (test_apimanager.TestApiManager mtodo), 89 test_write_conparin_3() (test_apimanager.TestApiManager mtodo), 89 test_write_gpecin() (test_apimanager.TestApiManager mtodo), 89 TestApiManager (clase en test_apimanager), 88
U
UML, 130 usabilidad, 130
W
wrapper, 131
134
ndice

Report

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Report

Hochgeladen von

Copyright:

Verfügbare Formate

Software para la gracacin de diagramas termodinmicos

Proyecto Integrador de Ingeniera en Computacin

Director Mg. Gustavo Wolfmann Codirector Dr. Martn Cismondi Duarte

A Nati y a mi familia, por todo el amor

6.3. 6.4. 6.5. 6.6. 6.7. 6.8. 6.9.

Software para la gracacin de diagramas termodinmicos

Software para la gracacin de diagramas termodinmicos

1.5.2 Objetivos especcos

2.1 Diagrama de fases de sistemas binarios

Software para la gracacin de diagramas termodinmicos

2.2 Equilibrio termodinmico

Software para la gracacin de diagramas termodinmicos

Figura 2.2: Un diagrama P-T-x para un sistema binario de Tipo I.

2.2. Equilibrio termodinmico

Software para la gracacin de diagramas termodinmicos

2.3 Ecuaciones de Estado

Captulo 2. Marco Terico

2.4 Aplicacin y utilidad

2.4. Aplicacin y utilidad

Software para la gracacin de diagramas termodinmicos

Captulo 2. Marco Terico

3.1 Trabajo interdisciplinario

Software para la gracacin de diagramas termodinmicos

3.2 Software libre

Captulo 3. Contexto de trabajo

Software para la gracacin de diagramas termodinmicos

3.2. Software libre

Software para la gracacin de diagramas termodinmicos

Captulo 3. Contexto de trabajo

Software para la gracacin de diagramas termodinmicos

Traduccin del ingls propia del autor del trabajo.

3.2. Software libre

Software para la gracacin de diagramas termodinmicos

Vea FUD en el glosario

Captulo 3. Contexto de trabajo

4.1 Metodologa de relevamiento

4.2 Relevamiento de la versin preexistente

Software para la gracacin de diagramas termodinmicos

4.2.2 Descripcin general

Captulo 4. Ingeniera de requerimientos

Software para la gracacin de diagramas termodinmicos

4.2.4 Aspectos de ingeniera de software

4.2.5 Problemas detectados

Captulo 4. Ingeniera de requerimientos

Software para la gracacin de diagramas termodinmicos

4.2. Relevamiento de la versin preexistente

Software para la gracacin de diagramas termodinmicos

4.3 Especicacin de requerimientos

Captulo 4. Ingeniera de requerimientos

4.3.2 Requerimientos no funcionales

4.4 Requerimientos especiales

4.4.1 Un proyecto, muchos casos

4.4. Requerimientos especiales

Software para la gracacin de diagramas termodinmicos

4.4.3 Superposicin automtica

4.4.4 Superposicin manual

4.4.5 Validacin de orden del sistema

La validez de esta funcin fue comprobada de manera emprica por Cismondi.

Captulo 4. Ingeniera de requerimientos

Software para la gracacin de diagramas termodinmicos

Tc14 T 14 1 < c2 Pc1 Pc 2

4.5 Casos de uso

4.5.1 Denir caso de estudio

Figura 4.5: Caso de uso: denicin de un caso de estudio en GPEC