simulador de procesos industrial
Post on 15-Apr-2016
35 Views
Preview:
DESCRIPTION
TRANSCRIPT
Proyecto Integrador Scortechini
Proyecto Integrador Scortechini
UNIVERSIDAD NACIONAL DE CÓRDOBA
Facultad de Ciencias Exactas, Físicas y Naturales
Departamento de Química Industrial y Aplicada
Escuela de Ingeniería Química
DESARROLLO DE UN SIMULADOR DE PROCESOS QUÍMICOS
Proyecto Integrador de la Facultad de Ciencias Exactas, Físicas y Naturales
de la Universidad Nacional de Córdoba conforme
a los requisitos para obtener el título de Ingeniero Químico
por
JULIÁN ANDRÉS SCORTECHINI
Córdoba
2015
Proyecto Integrador Scortechini
El proyecto Integrador DESARROLLO DE UN SIMULADOR DE PROCESOS
QUÍMICOS desarrollado por el alumno Julián Andrés Scortechini ha sido dirigido por
la Prof. MCs. Ing. Susana Martínez Riachi.
Directora del Proyecto Integrador
Nombre y Lugar de Trabajo
…………………….
firma
El presente proyecto integrador de la carrera de Ingeniería Química ha sido
aprobado el .…/.…/.….. , mereciendo la calificación de ......(……………………)
Tribunal Evaluador
Nombre Nombre Nombre
UNIVERSIDAD NACIONAL DE CÓRDOBA
Facultad de Ciencias Exactas, Físicas y
Naturales
Proyecto Integrador Scortechini
i
Proyecto Integrador Scortechini
DEDICATORIA
Dedico este trabajo a mis padres quienes con esfuerzo, sacrificio y mucho amor me
han guiado durante toda mi vida.
ii
Proyecto Integrador Scortechini
AGRADECIMIENTOS
El autor de este proyecto desea agradecer al Señor Rogelio Andrés Scortechini y a
la Señora Nelda Estela Soria por su constante aliento y paciencia durante la
confección de este trabajo.
Se agradece muy atentamente a la Señora Olga Scortechini, al Señor Andrés
Bonetto, a la Señora Florencia Foresi de Bonetto, a la Señorita Violeta Bonetto
Foresi, al Señor Laureano Bonetto, a la Señora María José Luna de Bonetto y al
joven Augusto Bonetto Luna por su constante aliento y por haber colaborado con el
autor de este proyecto proporcionando materiales para su ejecución.
También se desea agradecer al Señor Ariel Arguello, al Señor Mauro Domingo, a la
Señorita Florencia Buraschi y a la Señorita Vanesa Mascietti quienes han contribuido
a la ejecución de este proyecto de manera inestimable en calidad de amigos,
compañeros y colaboradores.
El autor de esta obra valora personalmente al Ingeniero Martín E. Gaitán, a todo el
personal de la empresa PHASETY, a los Ingenieros Susana Martínez Riachi y Daniel
L. Yorio, al Señor Maximiliano Duarte, como así también a toda la Escuela de
Ingeniería Química quienes han contribuido al desarrollo de este proyecto
proporcionando apoyo, conocimientos, materiales e instalaciones.
iii
Proyecto Integrador Scortechini
ÍNDICE GENERAL
Capítulo 1: Introducción a la simulación de procesos ................................................. 1
Introducción ............................................................................................................. 1
Historia ..................................................................................................................... 1
Hoy ........................................................................................................................... 3
Clasificación de los métodos de simulación ............................................................. 5
Simulación cualitativa y cuantitativa ..................................................................... 6
Simulación estacionaria y dinámica. ..................................................................... 6
Clasificación de simuladores .................................................................................... 7
Simuladores Globales u orientados a ecuaciones ................................................ 8
Simuladores Secuenciales-Modulares ................................................................ 10
Simuladores Híbridos.......................................................................................... 13
Características de los Simuladores Comerciales ................................................... 15
Nuestro Simulador ................................................................................................. 18
Bibliografía ............................................................................................................. 19
Capítulo 2: Objetivos ................................................................................................. 20
Objetivos Generales ............................................................................................... 20
Objetivos Específicos ............................................................................................. 20
Capítulo 3: Programación .......................................................................................... 21
Introducción ........................................................................................................... 21
Programación orientada a objetos ......................................................................... 22
Definición de objeto ............................................................................................ 22
Definición de Mensaje......................................................................................... 24
Definición de Clase ............................................................................................. 26
Herencia ............................................................................................................. 26
Selección del lenguaje de programación ............................................................... 28
iv
Proyecto Integrador Scortechini
El lenguaje Python ................................................................................................. 30
Bibliografía ............................................................................................................. 32
Capítulo 4: Termodinámica ....................................................................................... 33
Introducción ........................................................................................................... 33
Propiedades termodinámicas generales ................................................................ 34
Sistemas ideales .................................................................................................... 37
Mezclas de gases ideales ................................................................................... 37
La solución ideal ................................................................................................. 38
Sistemas no ideales ............................................................................................... 39
Propiedades Residuales de las Sustancias puras .............................................. 40
Propiedades Residuales de las Mezclas ............................................................ 45
Propiedades en Exceso de las Mezclas líquidas ................................................ 51
Biblioteca de Funciones Termodinámicas .............................................................. 57
Bibliografía ............................................................................................................. 59
Capítulo 5: Objetos Desarrollados ............................................................................. 60
Introducción ........................................................................................................... 60
La clase Pantalla .................................................................................................... 60
La clase BaseDeDatos ........................................................................................... 62
La clase Proyecto................................................................................................... 63
La clase SistemaTermodinamico ........................................................................... 65
Los primeros pasos ................................................................................................ 72
Corriente ................................................................................................................ 85
Nodo Divisor .......................................................................................................... 94
Mezclador ............................................................................................................ 101
Flash .................................................................................................................... 109
Intercambiador de Calor ....................................................................................... 115
Menús Auxiliares .................................................................................................. 121
El menú Herramientas ...................................................................................... 121
v
Proyecto Integrador Scortechini
El Menú Ver ...................................................................................................... 124
El Menú Ayuda ................................................................................................. 125
Bibliografía ........................................................................................................... 127
Capítulo 6: Problemas y dificultades ....................................................................... 128
Introducción ......................................................................................................... 128
Resolución de ecuaciones ................................................................................... 128
Niveles de iteración .............................................................................................. 130
Cálculo de temperaturas y balances de energía .................................................. 131
Eliminación de equipos ........................................................................................ 131
Reconstrucción del diagrama de flujo .................................................................. 132
Conexión de los equipos ...................................................................................... 132
Capítulo 7: Conclusiones ........................................................................................ 133
Anexo A: Cálculos Termodinámicos ........................................................................ 135
Sistemas Ideales .................................................................................................. 135
Mezclas de gases ideales ................................................................................. 135
La solución ideal ............................................................................................... 136
Sistemas no ideales ............................................................................................. 138
Propiedades residuales .................................................................................... 138
Coeficiente de Actividad ................................................................................... 140
Anexo B: Cálculos de Corriente .............................................................................. 142
Anexo C: Cálculos de Nodo Divisor ........................................................................ 146
Anexo D: Cálculos de Mezclador ............................................................................ 148
vi
Proyecto Integrador Scortechini
ÍNDICE DE ABREVIATURAS
Operador de derivación parcial
A Parámetro de la Ecuación Actividad
a, b, q, I Parámetros de las ecuaciones cúbicas de estado
Ai, Bi, Ci Constantes de la ecuación de Antoine
AIChe American Institute of Chemical Engineers
atm Atmósfera
B Segundo coeficiente Virial
beta, Fracción de vapor
CAS Computer Algebra System
Cp Capacidad calorífica molar
Variación
d Operador de derivación total
DFI Diagrama de Flujo de Información
DTML, ΔTML Diferencia de Temperatura Media Logarítmica
tolerancia del error
E (Supraíndice) Exceso
Constantes de las ecuaciones cúbicas de estado
ej. elemplo
ENIAC Electronic Numerical Integrator And Computer
EOS Ecuaciones de Estado
etc. etcétera
F Caudal de corriente
f fugacidad
coeficiente de fugacidad de una especie pura
Cociente entre los coeficientes de fugacidad en fase gaseosa y en fase líquida
FORTRAN Formula Translator
G Energía libre de Gibbs
Coeficiente de actividad
gi (Supraíndice) gas ideal
GL Grados de Libertad
GPSS General Purpose Simulation System
H Entalpía molar i, j, k (subíndices) Especie química
IBM International Business Machines Corp.
id (Supraíndice) ideal, relativo a una solución ideal
K relación de equilibrio, y/x
Coeficiente binario de la ecuación de Wilson
Energía de interacción binaria en la ecuación de Wilson
ln logaritmo natural
M Propiedad genérica
Potencial químico
Mac OS Macintosh Operating System
vii
Proyecto Integrador Scortechini
MATLAB MATrix LABoratory
MS MicroSoft
n Número de moles
N Número total de especies químicas
ni Número de moles de la especie "i"
NRTL Non-Random Two-Liquid
NumPy Numerical Python
P Presión
p presión parcial
Pc Presión crítica
PDF formato de documento portátil
PM Peso molecular
Pr Presión crítica
PR Ecuación de Peng-Robinson
Pydoc Python Document
Pyxls Python Excel
Q Flujo de calor
R Constante de los gases ideales
R (Supraíndice) Residual
RAND Research ANd Development
RK Ecuación de Redlich-Kwong
S Entropía molar
Operador de Sumatoria
sat saturación de un líquido o vapor
SciPy Scientific Python
SIMSCRIPT Simulation Script
Sobrebarra Propiedad molar parcial
SRK Ecuación de Soave-Redlich-Kwong
SymPy Symbolic Python
T Temperatura
Tc Temperatura crítica
Tr Temperatura reducida
U Energía interna molar
U Coeficiente global de transferencia de calor
V Volumen molar
Vc Volumen crítico
Factor acéntrico en cálculos termodinámicos. Fracción en masa.
W Flujo de trabajo
WSC Winter Simulation Conference
x Fracción molar en fase líquida
y Fracción molar en fase gaseosa
z Fracción molar global
Z Factor de compresibilidad
Zc Factor de compresibilidad en el punto crítico
𝑓 Fugacidad de una especie en solución
�̂� Coeficiente de fugacidad de una especie en solución
viii
Proyecto Integrador Scortechini
ÍNDICE DE FIGURAS
Figura 1. Representación gráfica de un objeto 22
Figura 2. Modelo de un flash 23
Figura 3. Comunicación entre objetos a través de mensajes 24
Figura 4. Mezclador como ejemplo de clase 26
Figura 5. Clase Equipo como superclase de otras 28
Figura 6. Pantalla del simulador 60
Figura 7. Procedimiento para calcular la temperatura de burbuja 67
Figura 8. Procedimiento para calcular la temperatura de rocío 68
Figura 9. Pantalla de Configuración de HYSYS 73
Figura 10. Otra pantalla de Configuración de HYSYS 73
Figura 11. Pantalla de configuración de UNISIM 74
Figura 12. Pantalla de selección de compuestos de UNISIM 74
Figura 13. Menú de configuración general del simulador 75
Figura 14. Diálogo de configuración general 76
Figura 15. Mensaje de error durante la configuración de Cp líquidos 77
Figura 16. Diálogo de configuración para Cp líquidos 78
Figura 17. Parámetros de los modelos de actividad 78
Figura 18. Menú Archivo del simulador 79
Figura 19. Diálogo para nombrar el proyecto 80
Figura 20. Diálogo de apertura de proyectos 80
Figura 21. Menú Insertar del simulador 82
Figura 22. Diálogo para nombrar un nuevo equipo 82
Figura 23. Menú emergente y sus distintas opciones 84
Figura 24. Ejemplo de un pequeño diagrama de flujo 84
Figura 25. Representación de una corriente 85
Figura 26. Diálogo de configuración de corriente 90
Figura 27. Generación de incógnitas, ecuaciones y grados de libertad 92
Figura 28. Resolución de ecuaciones de corriente 93
Figura 29. Representación gráfica de un nodo divisor 94
Figura 30. Diálogo de configuración de un nodo divisor 97
Figura 31. Selección de corrientes del nodo divisor 98
Figura 32. Carga de datos en diálogo de nodo divisor 99
Figura 33. Actualización de un nodo divisor 100
ix
Proyecto Integrador Scortechini
Figura 34. Resolución completa de un nodo divisor 101
Figura 35. Representación gráfica de un mezclador 101
Figura 36. Diálogo de configuración de un mezclador 105
Figura 37. Selección de corrientes del mezclador 106
Figura 38. Carga de datos en diálogo de mezclador 107
Figura 39. Actualización y resolución de un mezclador 108
Figura 40. Representación gráfica de un flash 109
Figura 41. Diálogo de configuración de flash 112
Figura 42. Actualización y resolución de flash 114
Figura 43. Representación de un flash en UNISIM 114
Figura 44. Resultados de cálculo flash con UNISIM 115
Figura 45. Representación gráfica de un intercambiador de calor. 115
Figura 46. Configuración de un intercambiador de calor. 119
Figura 47. Actualización de un intercambiador de calor. 120
Figura 48. Resolución completa de un intercambiador de calor. 121
Figura 49. Menú Herramientas. 122
Figura 50. Diálogo de Consulta a Biblioteca. 123
Figura 51. Diálogo para agregar nuevo compuesto. 124
Figura 52. Diálogo para editar compuesto. 124
Figura 53. Opciones del menú Ver. 125
Figura 54. El menú Ayuda. 126
Figura 55. Diálogo Acerca de los Autores. 126
Figura 56. Configuración general para el Ejemplo 6. 142
Figura 57. Diálogo de configuración de corriente del Ejemplo 6. 143
Figura 58. Completando los datos de la corriente. 143
Figura 59. Corriente del Ejemplo 6 resuelta. 144
Figura 60. Propiedades de la corriente del Ejemplo 7. 145
Figura 61. Diálogo de configuración de nodo divisor para el Ejemplo 8. 146
Figura 62. Carga de datos para el Ejemplo 8. 147
Figura 63. Nodo divisor y corrientes del Ejemplo 8 resueltos. 147
Figura 64. Diálogo de configuración de mezclador para el Ejemplo 9. 148
Figura 65. Resultados del Ejemplo 9. 149
x
Proyecto Integrador Scortechini
ÍNDICE DE TABLAS
Tabla 1. Principales características de los simuladores Globales u
orientados a ecuaciones 9
Tabla 2. Principales Características de los Simuladores 10
Modulares Secuenciales.
Tabla 3. Factores ponderados para seleccionar el lenguaje de
programación 29
Tabla 4. Parámetros de las ecuaciones cúbicas de estado 43
Tabla 5. Análisis de Corriente 85
Tabla 6. Análisis de Nodo Divisor 95
Tabla 7. Análisis de Mezclador 102
Tabla 8. Análisis de Flash 109
Tabla 9: Análisis de Intercambiador de Calor 116
Tabla 10. Comparación de propiedades residuales entre ecuaciones de
estado 139
xi
Proyecto Integrador Scortechini
RESUMEN
Palabras clave: Simulador, Ingeniería, Química, Híbrido, Balances, Educativo,
Python, Objetos.
En el presente proyecto se desarrolló un simulador de procesos químicos con fines
educativos. Se optó por el diseño de un programa híbrido que combine los mejores
aspectos de los simuladores modulares secuenciales y de aquellos orientados a
ecuaciones. Se utilizó el lenguaje de programación Python para codificar el proyecto
por sus excelentes recursos de programación orientada a objetos, cálculos
vectoriales, numéricos y simbólicos aplicables a la Ingeniería. El programa obtenido
es capaz de realizar balances de materia y de energía, así como cálculos
termodinámicos avanzados, con gran precisión. Posee una amplia variedad de
modelos termodinámicos disponibles como ecuación del gas ideal, ecuación Virial,
ecuaciones cúbicas de estado, solución ideal, ecuaciones de Margules, Van Laar y
Wilson. También se construyó una interface gráfica de usuario moderna, que permita
una comunicación eficiente y amigable con el usuario. La misma permite una
configuración del sistema de unidades, seleccionar compuestos entre una lista de
más de 450 especies químicas orgánicas e inorgánicas y trabajar con caudales
molares o másicos. El software permite además representar el diagrama de flujo del
proceso a simular, identificando a cada equipo o accesorio de proceso con un ícono
característico. La comunicación con el usuario se realiza mediante diálogos que
hacen el proceso de configuración cómodo y natural. Cada equipo se caracteriza
mediante un objeto informático constituido por atributos que simbolizan las
propiedades del equipo y métodos que implementan su comportamiento e
interacciones. El proceso de modelado de cada operación se basa en la
identificación de las propiedades desconocidas, la abstracción de las mismas con
símbolos algebraicos, el planteo de ecuaciones y la contabilización del número de
grados de libertad. Entre las ecuaciones se encuentran algunas generales como las
del balance de masa, de energía o de equilibrio de fases, las de restricción como la
suma de fracciones molares igual a uno y otras específicas como aquellas propias
de un modelo termodinámico o una operación en particular. Para la resolución de
esas ecuaciones se utilizaron herramientas de cálculo propias del lenguaje Python y
en casos excepcionales se programaron métodos numéricos específicos para un tipo
particular de problema.
1
Proyecto Integrador Scortechini
Capítulo 1: Introducción a la simulación de procesos
Introducción
El objetivo de todo simulador consiste en reproducir la realidad de la mejor manera
posible. Si existiera un simulador capaz de representar las condiciones de la
realidad, el usuario no podría distinguir los sucesos simulados de los reales. Sin
embargo en la práctica ésta resulta tan compleja que ningún programa de
computadora puede reproducirla totalmente, se habla entonces del grado de
aproximación con que dicho programa refleja el comportamiento real de los sistemas
simulados. La experiencia demuestra que a medida que se incrementa la capacidad
de simulación también aumenta la complejidad del software.
Las herramientas informáticas implementan una serie de modelos matemáticos y
algoritmos de decisión, basados en la lógica, para simular procesos industriales.
Historia
La historia de la simulación nace en 1777 con el planteo del problema “La aguja de
Buffon”, un método matemático sencillo para ir aproximando el valor del número Pi a
partir de sucesivos intentos.
En 1812 Laplace mejoró y corrigió la solución de Buffon y desde entonces se conoce
como solución Buffon-Laplace.
Posteriormente, el estadístico William Sealy Gosset, que trabajaba en la destilería de
Arthur Guinness, ya aplicaba sus conocimientos estadísticos allí, como también en
su propia explotación agrícola. El especial interés de Gosset en el cultivo de la
cebada le llevó a especular que el diseño de experimentos debería dirigirse no sólo
a mejorar la producción media, sino también a desarrollar variedades de cebada
cuya mayor robustez permitiese que la producción no se viese afectada por las
variaciones en el suelo y el clima. Para evitar futuras filtraciones de información
confidencial, Guinness prohibió a sus empleados la publicación de cualquier tipo de
artículo independientemente de su contenido, de ahí el uso que hizo Gosset en sus
publicaciones del seudónimo "Student", para evitar que su empleador lo detectara.
2
Proyecto Integrador Scortechini
Es por esta razón que su logro más famoso se conoce como la "distribución t de
Student", que de otra manera hubiera sido conocida como la "distribución t de
Gosset”. Este hito histórico abrió las puertas a la aplicación de la simulación en el
campo del proceso de control industrial así como a las sinergias que generaba esta
simulación basada en la experimentación y técnicas de análisis para descubrir
soluciones exactas a problemas clásicos de la industria y la ingeniería.
A mediados de la década de 1940 dos hechos sentaron las bases para la rápida
evolución del campo de la simulación:
La construcción de las primeras computadoras de propósito general como el
ENIAC.
El trabajo de Stanislaw Ulam, John Von Neumann y otros científicos para usar
el método de Montecarlo en computadoras modernas y solucionar problemas
de difusión de neutrones en el diseño y desarrollo de la bomba de hidrógeno.
Ulam y Von Neumann ya estuvieron presentes en el proyecto Manhattan.
En 1960, Keith Douglas Tocher desarrolló un programa de simulación general cuya
principal tarea era la de simular el funcionamiento de una planta de producción
donde las máquinas alternaban por los estados: Ocupado, Esperando, No disponible
y Fallo; de manera que las simulaciones en los cambios de estado de las máquinas
marcaran el estado definitivo de la producción de la planta. Este trabajo produjo
además el primer libro sobre simulación: “The Art of Simulation” (1963).
Para aquel entonces, IBM desarrolló entre 1960 y 1961 el Sistema de Simulación de
Propósito General o General Purpose Simulation System (GPSS). El GPSS se
diseñó para realizar simulaciones de teleprocesos involucrando por ejemplo: control
de tráfico urbano, gestión de llamadas telefónicas, reservas de pasajes de avión, etc.
La sencillez de uso de este sistema lo popularizó como el lenguaje de simulación
más usado de la época.
Por otro lado, en 1963 se desarrolló SIMSCRIPT, otra tecnología alternativa al GPSS
basada en FORTRAN, más enfocada a usuarios que no tenían por qué ser
obligatoriamente expertos informáticos en RAND CORPORATION.
Complementariamente a los desarrollos llevados a cabo por RAND e IBM, el Royal
Norwegian Computing Center inició en 1961 el desarrollo del programa SIMULA con
ayuda de Univac. El resultado fue SIMULA I.
3
Proyecto Integrador Scortechini
En 1967 se fundó el WSC (Winter Simulation Conference), lugar donde desde
entonces y hasta ahora se archivan los lenguajes de simulación y aplicaciones
derivadas, siendo en la actualidad el referente en lo que a avances en el campo de
los sistemas de simulación se refiere.
Durante este periodo se desarrollaron avanzadas herramientas de modelado y de
análisis de resultados. Gracias también a los desarrollos obtenidos en la generación
de datos y a las técnicas de optimización y representación de datos, la simulación
llega a su fase de expansión donde comienza a aplicarse en múltiples campos.
Anteriormente, los datos de salida obtenidos de una simulación por computadora se
presentaban en una tabla o matriz, de manera que se mostraba el efecto que los
múltiples cambios en los parámetros tenían sobre los datos. El empleo del formato
de matriz se debía al uso tradicional que se hacía de la matriz en los modelos
matemáticos. Sin embargo, los psicólogos advirtieron que los seres humanos
percibían mejor los cambios en el desarrollo de las situaciones si miraban gráficos o
incluso imágenes en movimiento o animaciones generadas a partir de dichos datos,
como las que se ejecutan en las animaciones de imágenes creadas por
computadora.
En 1981 Aparecen los softwares para la simulación de procesos químicos en PC.
Pronto aparecen programas tales como: DESIGN II, ASPEN, SIMSCI (PRO II),
HYSIM, CHEMCAD. etc. (LANDER, 2014).
Hoy
En la actualidad la simulación de procesos se encuentra en un estado de desarrollo
avanzado, aun expandiéndose pero a menor velocidad que en las décadas pasadas.
Los simuladores disponibles en la actualidad se caracterizan por una alta calidad
para representar los procesos simulados, cuentan con interfaces gráficas de usuario
modernas y amigables. También ha aumentado su potencia de cálculo y de
procesamiento de la información de la mano con la evolución de la tecnología
disponible en las computadoras de hoy en día y con la mejora en los modelos
matemáticos usados para representar fenómenos fisicoquímicos.
4
Proyecto Integrador Scortechini
Actualmente la simulación de procesos se ve como un procedimiento sistemático
compuesto por las siguientes etapas:
Formulación del problema: En este paso debe quedar perfectamente establecido
el objeto de la simulación. Se deben definir lo más detalladamente posible los
siguientes factores: los resultados que se esperan del simulador, el plan de
experimentación, el tiempo disponible, las variables de interés, el tipo de
perturbaciones a estudiar, el tratamiento estadístico de los resultados, la complejidad
de la interfaz del simulador, etc. Se debe establecer si el simulador será operado por
el usuario o si el usuario sólo recibirá los resultados. Finalmente, se debe establecer
si el usuario necesita una simulación o una optimización.
Definición del sistema: El sistema a simular debe estar perfectamente definido. Es
necesario establecer la frontera del sistema a estudiar y las interacciones con el
medioambiente que serán consideradas.
Formulación del modelo: Esta etapa es un arte. La misma comienza con el
desarrollo de un modelo simple que captura los aspectos relevantes del sistema real.
Los aspectos relevantes del sistema real dependen de la formulación del problema;
para un ingeniero de seguridad los aspectos relevantes de una planta son diferentes
de los aspectos considerados por un ingeniero químico o electromecánico para el
mismo sistema. Este modelo simple se irá enriqueciendo como resultado de varias
iteraciones.
Colección de datos: La naturaleza y cantidad de datos necesarios están
determinadas por la formulación del problema y del modelo. Los datos pueden ser
provistos por bases de datos, experimentos de laboratorios o mediciones realizadas
en un equipo real. Los mismos deberán ser procesados adecuadamente para darles
el formato exigido por el modelo.
Implementación del modelo en la computadora: El modelo es implementado
utilizando algún lenguaje de programación. Existen lenguajes específicos de
simulación que facilitan esta tarea; también, existen programas que ya cuentan con
modelos implementados para casos especiales.
Verificación: En esta etapa se comprueba que no se hayan cometidos errores
durante la implementación del modelo. Para ello, se utilizan las herramientas de
depuración provistas por el entorno de programación.
5
Proyecto Integrador Scortechini
Validación: En esta etapa se comprueba la exactitud del modelo desarrollado. Esto
se lleva a cabo comparando las predicciones del modelo con: mediciones realizadas
en el sistema real, datos bibliográficos o de sistemas similares. Como resultado de
esta etapa puede surgir la necesidad de modificar el modelo o recolectar datos
adicionales.
Diseño de experimentos: En esta etapa se decide las características de los
experimentos a realizar: el tiempo de arranque, el tiempo de simulación y el número
de simulaciones.
Experimentación: En esta etapa se realizan las simulaciones de acuerdo al diseño
previo. Los resultados obtenidos son debidamente recolectados y procesados.
Interpretación: Se analiza la sensibilidad del modelo con respecto a los parámetros
que tienen asociados la mayor incertidumbre. Si es necesario, se deberán recolectar
datos adicionales para refinar la estimación de los parámetros críticos.
Implementación: Conviene acompañar al usuario en la etapa de implementación
para evitar el mal manejo del simulador o el mal empleo de los resultados del mismo.
Documentación: Incluye la elaboración de la documentación técnica y manuales de
uso. La documentación técnica debe contar con una descripción detallada del
modelo y de los datos; también, se debe incluir la evolución histórica de las distintas
etapas del desarrollo. Esta documentación será de utilidad para el posterior
perfeccionamiento del simulador (Tarifa, 2015).
Clasificación de los métodos de simulación
Las herramientas de simulación pueden clasificarse según diversos criterios, por
ejemplo, según el tipo de procesos (batch o continuo), si involucra el tiempo
(estacionario o dinámico -incluye a los equipos batch-), si maneja variables
estocásticas o determinísticas, variables cuantitativas o cualitativas, etc.
A continuación se expondrán brevemente las características de los distintos tipos de
herramientas de simulación generalmente utilizadas.
6
Proyecto Integrador Scortechini
Simulación cualitativa y cuantitativa
La simulación cualitativa tiene por objeto principalmente el estudio de las relaciones
causales y las tendencias temporales cualitativas de un sistema, como así también
la propagación de perturbaciones a través de un proceso dado. Llamamos valores
cualitativos de una variable, a diferencia del valor numérico (cuantitativo), a su signo;
ya sea absoluto, o bien con relación a un valor dado o de referencia. Por lo tanto, en
general se trabaja con valores tales como (+, -, 0). Son varios los campos de
aplicación de la simulación cualitativa, por ejemplo el análisis de tendencias,
supervisión y diagnóstico de fallas, análisis e interpretación de alarmas, control
estadístico de procesos, etc.
La simulación cuantitativa, en cambio, es aquella que describe numéricamente el
comportamiento de un proceso, a través de un modelo matemático del mismo. Para
ello se procede a la resolución de los balances de materia, energía y cantidad de
movimiento, junto a las ecuaciones de restricción que imponen aspectos funcionales
y operacionales del sistema. La simulación cuantitativa abarca principalmente la
simulación en estado estacionario y la simulación en estado dinámico.
Simulación estacionaria y dinámica.
La simulación en estado estacionario implica resolver los balances de un sistema
que no involucra la variable temporal, por lo que el sistema de ecuaciones deberá
estudiar o reflejar en el modelo las variaciones de las variables de interés con las
coordenadas espaciales (modelos a parámetros distribuidos); entonces deberá
utilizarse un sistema de ecuaciones diferenciales a derivadas parciales (según el
número de coordenadas espaciales consideradas). Un ejemplo puede ser la
variación radial de la composición en un plato en una columna de destilación, la
variación de las propiedades con la longitud y el radio en un reactor tubular, etc.
Por otra parte, y como su nombre lo indica, la simulación dinámica plantea los
balances dependientes del tiempo, ya sea para representar el comportamiento de
equipos batch, o bien para analizar la evolución que se manifiesta en el transitorio
entre dos estados estacionarios para un equipo o una planta completa. En este
caso, el modelo matemático estará constituido por un sistema de ecuaciones
7
Proyecto Integrador Scortechini
diferenciales ordinarias cuya variable diferencial es el tiempo. En caso contrario, se
deberá resolver un sistema de ecuaciones diferenciales a derivadas parciales,
abarcando tanto las coordenadas espaciales como la temporal.
Desde el punto de vista de los fenómenos o sistemas que se estudian, la simulación
puede también clasificarse en determinística o estocástica. Como modelo
determinístico consideramos aquél en el cual las ecuaciones dependen de
parámetros y variables conocidos con certeza, es decir que no existe incertidumbre
ni leyes de probabilidades asociadas a las mismas. En cambio en un modelo
estocástico, como su nombre lo indica, ciertas variables estarán sujetas a
incertidumbre, que podrá ser expresada por funciones de distribución de
probabilidad. En este caso, por lo tanto, también los resultados del modelo estarán
asociados a una ley de probabilidad. En esta obra estudiaremos únicamente los
modelos determinísticos, dejando de lado los procesos estocásticos y la simulación
de los mismos.
Por último, también cabe mencionar la simulación de eventos discretos, en la cual
existen variables de interés que no tienen un comportamiento continuo. Existen
numerosos procesos que sólo pueden simularse desde este punto de vista. Por
ejemplo, la simulación o diseño de plantas batch multiproducto o multipropósito, o
ambas simultáneamente, poseen características que imponen un modelo discreto
para contemplar ciertos eventos de interés. Desde este punto de vista se deben
utilizar modelos especiales para tratar funciones semicontinuas y en presencia de
eventos discretos (Scenna, 1999).
Clasificación de simuladores
Los simuladores de procesos pueden dividirse en los siguientes tipos según el
enfoque bajo el cual se plantea el modelo matemático que representa el proceso a
simular:
simuladores globales u orientados a ecuaciones
simuladores secuenciales modulares
simuladores híbridos o modular secuencial-simultáneo
8
Proyecto Integrador Scortechini
Simuladores Globales u orientados a ecuaciones
Bajo el enfoque de la simulación global u orientada a ecuaciones, se plantea el
modelo matemático que representa al proceso construyendo un gran sistema de
ecuaciones algebraicas que representa a todo el conjunto o planta a simular. De
esta forma el problema se traduce en resolver un gran sistema de ecuaciones
algebraicas, por lo general altamente no lineales. Como ejemplo puede citarse en
problemas típicos de simulación de columnas de destilación por métodos rigurosos
el sistema de ecuaciones puede llegar a contener más de mil variables. De ello se
desprende la magnitud del sistema que represente el modelo de una planta
completa típica (Himmelblau, 1997).
En la década del 70, cuando se generan los primeros simuladores, no existían los
medios apropiados (principalmente hardware) para la resolución numérica de
sistemas de ecuaciones de gran dimensión. Es por ello que los primeros simuladores
comerciales adoptaron principalmente la arquitectura modular, en detrimento de la
global (Scenna, 1999).
El principal problema asociado a la filosofía de resolución global u orientada a
ecuaciones es la convergencia del sistema y la consistencia de las soluciones que
se encuentran. En efecto, los sistemas altamente no lineales como los que
corresponden a modelos de plantas químicas pueden, por ejemplo, producir
múltiples soluciones. Además, la solución numérica para grandes sistemas exige
estimaciones iniciales apropiadas, es decir próximas a un entorno de la solución, de
lo contrario pueden presentarse serios inconvenientes.
Históricamente, estas dificultades han sido la causa que ha limitado el desarrollo de
este tipo de simuladores en forma masiva. Una de las críticas fundamentales para la
operación de los mismos que se realizaba a menudo por parte de usuarios no
entrenados, era la imposibilidad de identificar los sectores de la planta en
correspondencia con el sistema de ecuaciones que lo representa, dado que una vez
que se hubo armado el sistema total, éste está integrado y se pierde la
correspondencia biunívoca entre el equipo y el subsistema de ecuaciones que lo
representa. De esta manera, si existieran inconvenientes durante la simulación,
resulta difícil asignar el problema a un sector específico de la planta, o bien inicializar
9
Proyecto Integrador Scortechini
convenientemente (Sifuentes, 2000). Las principales características (virtudes y
defectos históricamente remarcados) se resumen en la Tabla 1.1.
Tabla 1. Principales características de los simuladores Globales u orientados a ecuaciones
Cada equipo se representa por las ecuaciones que lo modelan. El modelo es la integración de todos los subsistemas.
Desaparece la distinción entre variables de proceso y parámetros operativos, por lo tanto se simplifican los problemas de diseño.
Resolución simultánea del sistema de ecuaciones algebraicas (no lineales) resultante.
Mayor velocidad de convergencia.
Necesita una mejor inicialización (mejor cuanto mayor sea el problema a resolver).
A mayor complejidad, menor confiabilidad en los resultados y más problemas de convergencia (soluciones sin sentido físico).
Más difícil de usar por "no especialistas".
Una ventaja importante es que puede logarse una velocidad de convergencia
cuadrática, esto es, mayor que en los simuladores secuenciales, como se verá más
adelante. Además, dado que el sistema se plantea orientado a ecuaciones, es
posible incorporar fácilmente las expresiones de restricción para definir problemas
de optimización en forma directa, ya que solo basta con plantear las restricciones y
la función de optimización. Esta flexibilidad es imposible en los simuladores
secuenciales modulares, debido a que los módulos están orientados y definidos en
forma rígida, esto es, resulta imposible agregar restricciones y/o variables, además
de la expresión analítica de la función de optimización, debiéndose proceder tipo
“caja negra” (Sifuentes, 2000).
10
Proyecto Integrador Scortechini
Simuladores Secuenciales-Modulares
Los simuladores modulares secuenciales se basan en módulos de simulación
independientes que siguen aproximadamente la misma filosofía que las operaciones
unitarias, es decir, cada equipo: bomba, válvula, intercambiadores de calor, etc.; es
simulado a través de modelos específicos para el mismo y además, el sentido de la
información coincide con el “flujo físico” en la planta. En esta filosofía se tiene como
ventaja el hecho que cada sistema de ecuaciones es resuelto con una metodología
que resulta adecuada para el mismo, ya que es posible analizar bajo todas las
circunstancias posibles, el comportamiento del método de resolución propuesto, esto
es sistemas ideales, no ideales, topología diversa del equipo, distintas variantes, etc.
Dado que se puede analizar específicamente la performance de los distintos
métodos de resolución es factible lograr un modelo robusto y eficiente para cada
módulo específico. (Himmelblau, 1997)
Tabla 2. Principales Características de los Simuladores Modulares Secuenciales.
Biblioteca de módulos (uno para cada equipo)
Flow sheet: Equivale a un grafo orientado o dígrafo
Orden de resolución fijo (iteraciones)
Tres niveles de iteración (se incorpora otro si se desea optimizar)
1. Cálculos fisicoquímicos. 2. Módulos en sí (ej. flash, columna, etc.). 3. Variables de iteración (reciclos). 4. Optimización
Modelos individuales resueltos eficientemente.
Fácilmente comprendido por ingenieros "no especialistas en simulación".
Métodos de convergencia robustos.
La información ingresada por el usuario (relacionable con equipos o corrientes) resulta fácilmente chequeable e interpretable.
Los problemas de diseño (selección de parámetros) son más difíciles de resolver.
Se incrementa la dificultad cuando se plantea un problema de optimización (funcionan como cajas negras).
Poco versátiles, pero muy flexibles, muy confiables y bastante robustos.
11
Proyecto Integrador Scortechini
Conceptualmente, bajo esta filosofía, para cada módulo de simulación (equipo)
deberá plantearse su modelo matemático. Obviamente, para encarar la solución de
cualquier sistema de ecuaciones deben diferenciarse los valores conocidos y los que
deben calcularse, todo esto teniendo en cuenta los grados de libertad; es decir, la
compatibilidad entre el número de ecuaciones y de incógnitas, a fin de obtener un
sistema con solución única. El enfoque en la teoría secuencial modular por definición
supone que se conocen (especifican) las variables de las corrientes de entrada, o
sea las alimentaciones a los equipos, mientras que deben calcularse las corrientes
de salida y los correspondientes parámetros de operación si correspondiera. Esto
según comentamos, impone cierta rigidez que sacrifica, según sea el caso, la
posibilidad de encontrar asignaciones tales que minimicen el tiempo de cómputo. Sin
embargo esto resulta conveniente desde otro punto de vista, ya que de esta manera
se impone una dirección al flujo de información entre módulos. Por otra parte, las
combinaciones posibles de especificación de variables son enormes,
incrementándose en forma dramática la cantidad de módulos a disponer si se
quisiera cubrir todas las posibilidades.
En general, fijada la orientación en el cálculo (esto es dadas las entradas calcular las
salidas del equipo), lograr que el sistema de ecuaciones sea compatible y tenga
tantas incógnitas como ecuaciones no implica necesariamente una única opción, ya
que debemos analizar las variables o parámetros de operación del equipo. En
efecto, en la mayoría de los casos existirán varias combinaciones de valores
posibles, es decir, existirán varias posibilidades de asignación de parámetros de
equipos. Además, existen variantes para cada módulo que tienen en cuenta varios
factores, como ser topología, -por ejemplo el número de entradas y salidas a una
torre de destilación, o si hay condensadores parciales o totales-, o bien el nivel de
las hipótesis realizadas (si se considera hidráulica de platos o no, pérdidas de calor
al ambiente, etc.). (Scenna, 1999)
Resumiendo, en un simulador modular se define cada módulo por un sistema de
ecuaciones independiente que se resuelve de la manera óptima, subordinados sin
embargo a las limitaciones que ha impuesto la especificación de variables
seleccionada. Esto implica una ventaja en el sentido que se podrían utilizar
progresivamente distintos niveles de cálculo dependiendo de la etapa del proyecto
en la que se realiza la simulación, o bien en función de los datos disponibles hasta el
momento, aprovechando el conocimiento que proviene de la experiencia y análisis
12
Proyecto Integrador Scortechini
del método de convergencia para cada caso en particular. No obstante, uno de los
problemas que se originan es la conexión de los módulos según el proceso a simular
y las rigideces que ello impone. La representación del diagrama de flujo (flow sheet)
del proceso se traduce a un diagrama similar, llamado diagrama de flujo de
información (DFI). Este diagrama matemáticamente es un dígrafo, en el cual los
nodos son los módulos de equipos conectados uno a uno a través de las corrientes
que los vinculan, las cuales se representan como arcos dirigidos. Estas corrientes de
información por lo general coinciden con las corrientes físicas de la planta, pero no
necesariamente en todos los casos. Lo mismo sucede con los equipos (nodos del
dígrafo). En algunas oportunidades, será necesario representar un equipo real de la
planta mediante la conexión de varios módulos disponibles en la biblioteca de
módulos del simulador.
En síntesis, dado que en la filosofía modular, por definición los módulos resultan
orientados, al construirse el diagrama de flujos del sistema, si éste contiene reciclos
será necesario disponer de un procedimiento de cálculo iterativo para resolver los
balances del proceso completo. Desde el punto de vista del análisis numérico, se
puede afirmar que bajo el procedimiento de la filosofía modular secuencial se
introducen tres niveles característicos de iteración, a diferencia de los simuladores
orientados a ecuaciones donde existe sólo uno. Se debe iterar al nivel de cálculos
fisicoquímicos, de módulos de equipos, y por último, a nivel del DFI o diagrama de
flujo de la planta completa. Más aún, para problemas en los cuales se defina la
optimización de alguna performance del proceso expresada según una función
objetivo y las variables de optimización correspondientes, se introduce un nuevo
nivel de iteración, por sobre el nivel correspondiente al DFI. (Sifuentes, 2000)
La estrategia de contemplar los grados de libertad posibles en la orientación de los
módulos para mejorar la performance y flexibilidad del simulador basado en una
óptica modular secuencial es utilizada por algunos simuladores comerciales para
disminuir el tiempo de cómputo al reducir el número de corrientes iteradoras.
13
Proyecto Integrador Scortechini
Simuladores Híbridos
Es posible plantear el desarrollo de simuladores combinando la estrategia modular y
la orientada a ecuaciones de forma tal de aprovechar los aspectos positivos de
ambas metodologías lo máximo posible. Para ello se selecciona un grupo de
variables sobre las cuales se procederá según la filosofía global, esto es, se las
resolverá simultáneamente, mientras que para el resto se mantiene la filosofía
modular, es decir, se trata de encontrar una secuencia acíclica, que provea por su
cálculo, en cada iteración, los valores de las variables a resolverse simultáneamente.
Es por ello que a esta filosofía también se la conoce como “two-tear” o “de dos
niveles jerárquicos”, ya que se trabaja en uno con las variables tratadas
simultáneamente, y en el otro secuencialmente. Otro nombre con el que se conoce
este enfoque es modular secuencial-simultáneo. (Scenna, 1999)
Con el advenimiento de nuevos paradigmas de programación (que, a diferencia de
los lenguajes estructurados, hacen posible la manipulación de información simbólica,
recursividad, programación orientada a objetos, etc.); se logra fácilmente generar
algoritmos que cumplan respecto del armado de un sistema de ecuaciones global; la
misma tarea lógica que debe realizarse en un simulador secuencial para administrar
los módulos parciales que representan la planta completa. En otras palabras, es
posible, tomando como dato el diagrama de flujo del proceso, diagramar una
“interfaz inteligente o lógica”, que “arme” el sistema de ecuaciones correspondientes
a los equipos seleccionados y de alguna forma considerar las interconexiones entre
los mismos, a través de la identificación de las corrientes de entrada - salida como
variables de conexión; elaborando de esta manera, a partir de los subsistemas, la
gran matriz que representa el sistema global de ecuaciones de toda la planta.
Consecuentemente, este sistema lógico (generación del sistema de ecuaciones que
representa la planta completa), sería la interfaz hacia el usuario; presentaría a éste
los equipos en un formalismo o lenguaje natural (como un simulador modular),
mientras que hacia el simulador los traduciría en un único sistema de ecuaciones a
ser resuelto. En este caso existiría una especie de banco o biblioteca de “módulos
conteniendo subsistemas de ecuaciones de balance genéricas”, y no módulos de
equipos (Henning, G., Leone, H., Stephanopoulos, Geo., 1990) (Himmelblau, 1997).
Además, la inicialización podría resolverse con la misma estrategia. Las
estimaciones correspondientes pueden ser volcadas en forma conveniente a la
14
Proyecto Integrador Scortechini
inicialización del sistema global, a través de la interfaz inteligente, que presentaría al
usuario “equipos” o variables con su “interpretación” física, pero hacia el simulador
los traduciría al lenguaje matemático, esto es, las variables correspondientes en el
sistema global de ecuaciones asociado a la planta completa.
En definitiva, la performance del sistema en cuanto a comunicación amigable,
transparencia y flexibilidad hacia el usuario, sería indistinguible respecto de uno
modular. La diferencia radicaría en la estructura asociada al problema matemático y
en la estrategia de resolución del sistema de ecuaciones de gran dimensión, que
como sabemos tiene una velocidad de convergencia cuadrática contra una menor
del sistema modular. Debe balancearse entonces velocidad de convergencia vs
robustez al resolver sistemas de ecuaciones de elevada dimensión, para optar entre
una filosofía u otra. A medida que evolucionan los algoritmos y el software
correspondiente para la solución de grandes sistemas de ecuaciones, mayor es la
facilidad con que puede implementarse esta nueva filosofía en el diseño de
simuladores de uso general. Más aún, existe en nuestros días una diversidad de
productos comerciales que parcialmente llevan a la práctica los principios aquí
discutidos. En efecto, uno de los condicionantes es la relativa necesidad de utilizar
un criterio orientado a ecuaciones al enfrentar la simulación dinámica de plantas
completas. Dado que los nuevos simuladores tienden a dotar al usuario de la
facilidad de simular la planta tanto en estado estacionario como dinámico, es
conveniente para el desarrollo de estos simuladores, migrar a la filosofía global
(Sifuentes, 2000).
Se espera que en el futuro los modelos estén basados progresivamente en la
filosofía global u orientada a ecuaciones debido al progreso del software y hardware.
Esto permitirá además mayor flexibilidad en el planteo de problemas muy diversos,
como la simulación estacionaria y dinámica, optimización, etc. Esto por otra parte,
obligará al usuario a conocer cada vez más los detalles, tanto matemáticos como
estructurales, así como también, la implementación de modelos específicos, ya que
en una filosofía orientada a ecuaciones, solo implica agregar un paquete de
ecuaciones adicionales a las contenidas en la “biblioteca” de módulos-ecuaciones
del simulador (Scenna, 1999).
15
Proyecto Integrador Scortechini
Características de los Simuladores Comerciales
Entre los programas de simulación que se encuentran disponibles en el mercado
actualmente se puede mencionar a: HYSIM, CHEMCAD, UNISIM.
A continuación se expondrán algunas de las principales ventajas y desventajas de
estos productos.
Ventajas
Metodología de cálculo en estado estacionario: los cálculos en el diagrama de
flujo son realizados automáticamente cuando el usuario aporta información.
Los resultados de cualquier cálculo pasan automáticamente a otra corriente u
operación que esté afectada por el cálculo, propagando los resultados a
través del diagrama de flujo. La información parcial (insuficiente para permitir
un cálculo completo) también es dirigida bidireccionalmente a través del
diagrama de proceso.
Metodología de cálculo en estado dinámico: cada operación unitaria individual
contiene la información necesaria para calcular su respuesta dinámica, así
como también integrar algebraicamente.
Multi-Flow sheet: Se puede instalar un número ilimitado de diagramas de flujo
en una simulación. La información de cualquier locación es accesible en
cualquier momento. (HoneyWell, 2010)
Sub-flow sheets y flow sheet “templates”: Cada diagrama de flujo posee un
paquete de fluidos (componentes, propiedades, reacciones, etc.). Un
subdiagrama aparece como una operación multientrada/salida y es resuelto
automáticamente como cualquier otra operación. Los “templates” (plantillas)
pueden ser construidos específicamente con paquetes de fluidos,
operaciones, corrientes, especificaciones del proceso, etc., y guardados en
disco.
Los cálculos de equilibrio de fase pueden ser automáticamente realizados por
el método apropiado para el diagrama de flujo. Una vez que la composición y
dos variables de estado (presión, temperatura, fracción de vapor o entalpía)
son conocidas para una corriente, esta es automáticamente calculada. Los
cálculos de las propiedades físicas son realizados automáticamente para
cada fase. (Godoy-Rodríguez, 2013)
16
Proyecto Integrador Scortechini
Diagramas de Flujo y Reportes configurables, en MS Word o MS Excel.
Poderosas capacidades de gráfico: curvas de destilación/absorción,
diagramas de fases, diagramas presión-temperatura vs. Concentración.
Datos exportables a Excel.
Poderosa herramienta de Optimización de Procesos. (Wikispaces, 2015)
Herramienta de Análisis de Sensibilidad
Interfaces con Lotus 1-2-3, Excel y AutoCAD (para producir diagramas de
ingeniería).
Conexión con Visual Basic/ Excel que le permite programar sus propias
operaciones unitarias dentro del diagrama de proceso, utilizando funciones
termodinámicas y la base de datos de sustancias puras desde Excel.
(Worldpress, 2011)
Convergencia de operaciones unitarias independientes del diagrama de
proceso. Esta característica es excelente para un manejo más veloz en
simulaciones grandes y complejas.
Preselección automática de modelos termodinámicos (CHEMCAD detecta el
tipo de sustancias en la catálogo de componentes y recomienda un modelo
termodinámico automáticamente. (Collantes-Wilmer, 2006)
Equilibrio Líquido-Líquido y Vapor-Líquido
Estimación de propiedades físicas de productos no definidos
Incluyen paquetes termodinámicos especiales para AMINAS y POLIMEROS.
Predicción de azeótropos, formación de dos fases líquidas, puntos de burbuja
y rocío a diferentes temperaturas y presiones.
Modelos de torres sencillas y rigurosas con cortes laterales.
Modelos rigurosos de equipos con platos y empaques aleatorios.
CHEMCAD no toma atajos, no supone etapas ideales, usa correlaciones
rigurosas de transferencia de masa aprobadas por reconocidas instituciones
como el AIChE.
Destilaciones Reactivas con hasta 20 reacciones.
Amplia base de datos de propiedades físicas de componentes puros (más de
1900). (Cabrera Benítez, 2007)
Disponibilidad de los métodos de Pitzer y NRTL para electrolitos fuertes y
débiles. Estos métodos han sido modificados para incluir parámetros de
interacción dependientes de la temperatura. (Aspen Technology Inc, 2003)
17
Proyecto Integrador Scortechini
Parámetros de interacción binaria y terciaria.
Datos de equilibrio de reacción de electrolitos en los sistemas industriales
más comunes.
Predicción automática del pH de la solución.
Desventajas
CHEMCAD:
o Sólo tiene programados cierta cantidad de problemas tipo para cada
equipo.
o Sólo posee el método de la temperatura media logarítmica para el
intercambio de calor y asume que ésta ocurre en condiciones ideales.
o El sistema de unidades se selecciona al principio y todos los datos
ingresados posteriormente deben estar en el sistema elegido. El
usuario no puede ingresar los datos en distintos tipos de unidades.
o Sólo muestra los resultados finales en los archivos de documentación y
no etapas de cálculo intermedias.
HYSIM y UNISIM:
o Tienen las opciones de configuración general y preferencias dispersas
en múltiples submenús de diferentes menús que no siguen un orden
lógico.
o Si bien los cuadros de diálogo son amigables están sobrecargados con
pestañas y subventanas que vuelven los procesos de configuración
tediosos al pasear al usuario por una gran cantidad de pantallas y
opciones.
o Poseen múltiples barras de herramientas con opciones variadas de
tipos y configuraciones de equipos que ocupan demasiado espacio en
pantalla.
o No toleran datos faltantes en la composición de las corrientes de
entrada, si se encuentra con alguno lo ajusta a creo (Aspen
Technology Inc, 2003) (HoneyWell, 2010).
18
Proyecto Integrador Scortechini
Nuestro Simulador
Este proyecto pretendía crear un simulador de tipo híbrido que combinara la mayor
velocidad de convergencia de los simuladores orientados a ecuaciones con la
especificidad para cada equipo característica de los programas modulares
secuenciales.
Era deseable que el software abordara de manera genérica el proceso como un todo
siguiendo la lógica orientada a ecuaciones. Sin embargo para simplificar esta tarea,
que podía ser considerable en procesos grandes, también fue necesario que el
simulador posea herramientas exclusivas de cada operación a simular que le
permitieran resolver algunas incógnitas de manera más rápida y eficiente.
Se buscó que el producto fuera bidireccional, o sea que la información ingresada por
el usuario, o calculada por el programa, se propagase hacia adelante y hacia atrás
en el proceso afectando a todos los equipos relacionados directa o indirectamente
por dichos eventos.
También resultó de interés que fuera predictor-corrector de modo que no solicitase
estimaciones iniciales de las variables a resolver y que luego de cada iteración los
resultados hallados fueran corregidos hasta minimizar el error asociado con ellos a
un nivel aceptable. También se pretendió que se solicitara la mínima cantidad de
información posible al usuario y que el simulador determinase en base a esa
información propiedades tales como número de fases, composición de ellas, cálculo
de temperaturas por correlación con valores de entalpía, etc.
En el presente proyecto se propuso además mejorar los aspectos de comunicación
entre el programa y el usuario de modo que fuera más amigable y natural.
En los capítulos finales del informe se retomará este punto y se realizará un análisis
de los resultados obtenidos.
19
Proyecto Integrador Scortechini
Bibliografía
Aspen Technology Inc. (2003). HYSYS Tutorial & Applications. Cambridge.
Cabrera Benítez, D. (2007). Diseño e Implementación de un Simulador de un SPU.
Collantes-Wilmer. (2006). Handbook of Unit Operations using CHEMCAD. Cyrius
Technology Inc.
Godoy-Rodríguez. (2013). (U. F. Rosario, Ed.) Recuperado el 20 de Abril de 2015
Himmelblau, D. M. (1997). Principios Básicos y Cálculos en Ingeniería Química.
México D.F.: Prentice Hall.
HoneyWell. (2010). UNISIM Design. London.
LANDER. (15 de Septiembre de 2014). Recuperado el 15 de Septiembre de 2014,
de http://www.landersimulation.com/formacion-con-simulacion/el-mundo-en-
movimiento/historia-de-la-simulacion/
Scenna, N. J. (1999). Modelado, Simulación y Optimización de Procesos Químicos.
Sifuentes, M. (2000). Simulación de Procesos en Ingeniería Químicia. México D.F.:
Plaza y Valdés Editores.
Tarifa, E. E. (2015). Teoría y Modelos de Simulación. Universidad Nacional de Jujuy.
Wikispaces. (2015). Recuperado el 20 de Abril de 2015, de
https://simulacionprocesos.wikispaces.com/Ventajas+y+desventajas
Worldpress. (Mayo de 2011). Worldpress. Recuperado el 15 de Abril de 2015, de
https://unitorunozeydiio.files.wordpress.com/2011/05/chemcad.pdf
20
Proyecto Integrador Scortechini
Capítulo 2: Objetivos
Objetivos Generales
1. Crear un programa de computadora capaz de resolver los cálculos asociados
a las operaciones unitarias de transferencia de calor y de masa.
2. Desarrollar una interface gráfica de usuario para el programa antes
mencionado.
Objetivos Específicos
1. Realizar un relevamiento de las tecnologías existentes.
2. Estudiar la programación orientada a objetos y la técnica de las interfaces
gráfica de usuario.
3. Desarrollar los elementos visuales (menús, botones, mensajes, etc.) que
conformarán la interface de comunicación con el usuario.
4. Crear módulos computacionales que representen a los compuestos químicos
y a los equipos involucrados en un proceso industrial.
5. Desarrollar una biblioteca de funciones que realicen cálculos termodinámicos
típicos y necesarios para el cálculo de propiedades fisicoquímicas.
6. Programar los balances de materia y energía para los distintos equipos de
proceso.
7. Integrar los elementos anteriores con los módulos de cálculo.
8. Realizar pruebas. Detectar fallas. Optimizar lo programado.
9. Confeccionar el manual de usuario.
21
Proyecto Integrador Scortechini
Capítulo 3: Programación
Introducción
En el siglo pasado se ha utilizado la programación estructurada como paradigma de
resolución de problemas. Aquella consiste en descomponer un problema complejo
en problemas más simples y éstos en otros más sencillos, continuando este proceso
hasta alcanzar un nivel de complejidad lo suficientemente bajo para que las tareas
involucradas puedan ser realizadas por una computadora. Por lo tanto esta filosofía
se caracteriza por la descomposición del problema en verbos, acciones que deben
ser llevadas a cabo en un orden determinado para conseguir resolver el problema
original. La estructura informática básica de la programación estructurada es el
procedimiento o la función, que son una serie de instrucciones que operan sobre las
variables involucradas en el proceso y producen un determinado resultado; de esta
forma se implementan informáticamente las acciones en las que se ha
descompuesto el problema del mundo real.
Hacia la última década del siglo pasado y la primera del presente fue ganando
impulso otra filosofía, la programación orientada a objetos. Esto se debió a la
necesidad de modelar de una forma más natural la realidad y también debido a la
complejidad creciente de los problemas a abordar. Este nuevo paradigma se basa
en la descomposición de los problemas en objetos. Un objeto es la representación
computacional de un concepto del mundo real que contiene toda la información
necesaria para definirlo. Esta información se compone de atributos y métodos. Los
atributos son las características del objeto, sus propiedades tales como dimensiones
físicas, color, temperatura, posición, energía, masa, etc. Mientras que los métodos
son funciones que se encargan de implementar los comportamientos que determinan
sus acciones propias. Los métodos pueden modificar los atributos del objeto al que
pertenecen y también los de otra entidad. Las interacciones con otros objetos que
forman parte del escenario se llevan a cabo mediante mensajes que intercambian
los objetos.
22
Proyecto Integrador Scortechini
Programación orientada a objetos
La programación orientada a objetos es una “filosofía”, un modelo de programación,
con su teoría y su metodología, que conviene conocer y estudiar. Un lenguaje
orientado a objetos es un lenguaje de programación que permite el diseño de
aplicaciones orientadas a objetos. Lo normal es que toda persona que vaya a
desarrollar aplicaciones orientadas a objetos aprenda primero la “filosofía” (o
adquiera la forma de pensar) y después el lenguaje, porque “filosofía” sólo hay una y
lenguajes muchos (Tarifa, 2015). En este capítulo se presentan los conceptos
básicos de la programación orientada a objetos desde un punto de vista global, que
resulta válido para cualquier lenguaje de programación.
Definición de objeto
Un objeto es un conjunto de variables (o datos) y métodos (o funciones)
relacionados entre sí. Los objetos en programación se usan para modelar objetos o
entidades del mundo real (una bomba, un intercambiador de calor, un evaporador,
por ejemplo). Un objeto es, por lo tanto, la representación en un programa de un
concepto, y contiene toda la información necesaria para abstraerlo: datos que
describen sus atributos y operaciones que pueden realizarse sobre los mismos. La
siguiente figura muestra una representación visual de un objeto.
Figura 1. Representación gráfica de un objeto.
Los atributos del objeto (estado) y lo que el objeto puede hacer (comportamiento)
están expresados por las variables y los métodos que componen el objeto
respectivamente.
23
Proyecto Integrador Scortechini
Estas variables reciben el nombre de variables instancia o variables miembro porque
se refieren al estado de un objeto en particular. En la programación orientada a
objetos un objeto en particular se denomina una instancia.
Además de variables, un objeto podría tener métodos. Estos métodos se denominan
formalmente métodos instancia o métodos miembro, ya que cambian el estado de
una instancia u objeto particular. La siguiente figura muestra un equipo modelado
como un objeto:
Figura 2. Modelo de un flash.
El diagrama anterior muestra las variables del objeto en el núcleo o centro del mismo
y los métodos rodeando el núcleo y protegiéndolo de otros objetos del programa.
Este hecho de empaquetar o proteger las variables miembro con métodos miembro
se denomina encapsulación. Este dibujo conceptual es la representación ideal de un
objeto y es el ideal que los programadores suelen buscar. Sin embargo, por razones
prácticas, es posible que un objeto desee exponer alguna de sus variables miembro,
o proteger otras de sus propios métodos o funciones miembro.
De todos modos, el hecho de encapsular las variables y las funciones miembro
relacionadas proporciona dos importantes beneficios a los programadores de
aplicaciones:
Capacidad de crear módulos: El código fuente de un objeto puede escribirse y
mantenerse independiente del código fuente del resto de los objetos. De esta
forma, un objeto puede pasarse fácilmente de una parte a otra del programa.
24
Proyecto Integrador Scortechini
Protección de la información: Un objeto tendrá una interfaz pública
perfectamente definida que otros objetos podrán usar para comunicarse con
él. De esta forma, los objetos pueden mantener información privada y pueden
cambiar el modo de operar de sus funciones miembros sin que esto afecte a
otros objetos que usen estas funciones miembro.
Definición de Mensaje
Normalmente un único objeto por sí solo no es muy útil. En general, un objeto
aparece como un componente más de un programa o una aplicación que contiene
muchos otros. Es precisamente haciendo uso de esta interacción que se consigue
una funcionalidad de mayor orden y modelar comportamientos mucho más
complejos.
Los objetos de un programa interactúan y se comunican entre ellos por medio de
mensajes. Cuando un objeto A quiere que otro objeto B ejecute una de sus
funciones miembro (métodos de B), el objeto A manda un mensaje al objeto B.
Figura 3. Comunicación entre objetos a través de mensajes.
En ocasiones, el objeto que recibe el mensaje necesita más información para saber
exactamente lo que tiene que hacer. Esta información se pasa junto con el mensaje
en forma de parámetro.
Las tres partes que componen un mensaje son:
1. El objeto al cual se manda el mensaje.
2. El método o función miembro que debe ejecutar.
25
Proyecto Integrador Scortechini
3. Los parámetros que necesita ese método.
Estas tres partes del mensaje (objeto destinatario, método y parámetros) son
suficiente información para que el objeto que recibe el mensaje ejecute el método o
la función miembro solicitada. Los mensajes proporcionan dos ventajas importantes:
El comportamiento de un objeto está completamente determinado (a
excepción del acceso directo a variables miembro públicas) por sus métodos,
por lo tanto los mensajes representan todas las posibles interacciones que
pueden realizarse entre objetos. Por ejemplo un objeto de la clase
“Nodo_Divisor” tiene un método “__init__” que crea automáticamente algunos
atributos (nombre, lista de ecuaciones, de incógnitas, etc.). Otro método
“Actualizar” que se encarga de incorporar nueva información proveniente del
diálogo de ese nodo y trata de cambiar el estado del nodo (valor de sus
propiedades) si es posible. Otros métodos cuyo propósito es evidente son:
“Buscar_Incognitas”, “Formular_Ecuaciones”, “CalcularGL” (calcula los grados
de libertad) y “Resolver”. Así, estos métodos definen completamente el
comportamiento del objeto “Nodo_Divisor”.
Los objetos no necesitan formar parte del mismo proceso, ni siquiera residir
en un mismo ordenador para mandarse mensajes entre ellos (y de esta forma
interactuar). Por ejemplo un botón de mezclador es un objeto diferente del
diálogo de mezclador y del objeto clase “Mezclador”, pero el botón
desencadena la creación del diálogo y le envía a éste último el
correspondiente objeto mezclador. El objeto “Mezclador”, que pertenece a un
objeto superior clase “Proyecto”, es independiente del botón, que pertenece a
otro objeto superior clase “Pantalla”, y también lo es del objeto diálogo que no
tiene superiores. Pero un mezclador intercambia información de propiedades
con el diálogo de configuración de mezclador y responde sólo a su botón.
26
Proyecto Integrador Scortechini
Definición de Clase
Una clase es una plantilla que define las variables y los métodos que son comunes
para todos los objetos de un cierto tipo.
De este modo todos los objetos de una misma clase tienen atributos y métodos en
común. Sin embargo el valor de los atributos de una instancia en particular puede
diferir del valor de esos mismos atributos en otra instancia, pero ambas pertenecen a
la misma clase y tienen los mismos tipos de atributos. De igual manera, el hecho de
que una instancia ejecute uno de sus métodos en un determinado momento no
implica que todas las instancias de la misma clase deban imitar ese comportamiento.
Figura 4. Mezclador como ejemplo de clase.
Herencia
Una vez que hemos visto el concepto de clase y el de objeto, estamos en
condiciones de introducir otra de las características básicas de la programación
orientada a objetos: el uso de la herencia.
El mecanismo de herencia permite definir nuevas clases partiendo de otras ya
existentes. Las clases que derivan de otras heredan automáticamente todo su
comportamiento, pero además pueden introducir características particulares propias
que las diferencian. Entonces se conocen como subclases o clases derivadas.
Como hemos visto, los objetos se definen a partir de clases. Con el mero hecho de
conocer a qué clase pertenece un objeto, ya se sabe bastante sobre él.
Además, no estamos limitados a un único nivel de herencia. El árbol de herencias o
jerarquía de clases puede ser tan extenso como necesitemos. Los métodos y las
27
Proyecto Integrador Scortechini
variables miembro se heredarán hacia abajo a través de todos los niveles de la
jerarquía. Normalmente, cuanto más abajo está una clase en la jerarquía de clases,
más especializado es su comportamiento.
La herencia es una herramienta clave para abordar la resolución de un problema de
forma organizada, pues permite definir una relación jerárquica entre todos los
conceptos que se están manejando. Es posible emplear esta técnica para
descomponer un problema de cierta magnitud en un conjunto de problemas
subordinados a él. La resolución del problema original se consigue cuando se han
resuelto cada uno de los problemas subordinados, que a su vez pueden contener
otros. Por consiguiente, la capacidad de descomponer un problema o concepto en
un conjunto de objetos relacionados entre sí cuyo comportamiento es fácilmente
identificable puede ser extraordinariamente útil para el desarrollo de programas
informáticos.
La herencia proporciona las siguientes ventajas:
Las clases derivadas o subclases proporcionan comportamientos
especializados a partir de los elementos comunes que hereda de la clase
base. A través del mecanismo de herencia los programadores pueden
reutilizar el código de la superclase tantas veces como sea necesario.
Los programadores pueden implementar las llamadas superclases abstractas,
que definen comportamientos genéricos. Las clases abstractas definen e
implementan parcialmente comportamientos, pero gran parte de estos
comportamientos no se definen ni se implementan totalmente. De esta forma,
otros programadores pueden hacer uso de estas superclases detallando esos
comportamientos con subclases especializadas. El propósito de una clase
abstracta es servir de modelo base para la creación de otras clases
derivadas, pero cuya implementación depende de las características
particulares de cada una de ellas.
28
Proyecto Integrador Scortechini
Figura 5. Clase Equipo como superclase de otras.
Se eligió a la programación orientada a objetos como paradigma de programación
para codificar la interface gráfica de usuario así como todos los cálculos a realizar
durante este proyecto. La razón de esto es que ese modelo se adapta perfectamente
a la forma de modelar los equipos de proceso y operaciones unitarias en Ingeniería
Química.
Selección del lenguaje de programación
Luego de haber seleccionado el estilo de programación el próximo paso fue elegir un
lenguaje de programación.
Los factores considerados para la selección fueron los siguientes:
1. El lenguaje debe ser compatible con múltiples sistemas operativos.
2. Debe soportar la programación orientada a objetos.
3. Debe tener una sintaxis los más sencilla posible.
4. Debe contar con bibliotecas de funciones que puedan simplificar la
codificación de operaciones matemáticas complejas (cálculo vectorial,
integración, ajuste de funciones, gráficos, etc.).
5. Debe ser posible y relativamente fácil crear aplicaciones.
29
Proyecto Integrador Scortechini
6. Debe tener la capacidad de escribir archivos que permitan preservar la
información, pero también documentar (que también sea legible por el
usuario).
7. Debe ser compatible con otros programas tales como gestores de bases de
datos, programas de representación gráfica, planillas de cálculo, etc.
Como posibles candidatos se consideró a FORTRAN, C++ y Python.
Para tomar la decisión se utilizó el método de los factores ponderados. Éste consiste
en asignarle a cada uno de los puntos enumerados arriba un factor de peso, de
modo que la suma de los factores sea la unidad; y luego calificar cada alternativa
con un puntaje del 0 al 10 donde 0 es el peor y 10 es el mejor. Entonces para cada
alternativa se multiplica el puntaje de cada ítem por su factor de peso y después se
suman para obtener el puntaje final. Aquella opción que tenga el mayor puntaje total
es la mejor. A continuación se muestra la tabla de factores ponderados.
Tabla 3. Factores ponderados para seleccionar el lenguaje de programación
Ítem Factor FORTRAN C++ Python
Calificación Puntaje Calificación Puntaje Calificación Puntaje
Compatibilidad
con sistemas
operativos
0.05 8 0.40 8 0.40 10 0.50
Programación
orientada a
objetos
0.20 8 1.60 7 1.40 9 1.80
Sintaxis simple y
clara 0.20 8 1.60 6 1.20 10 2.00
Bibliotecas de
funciones 0.20 8 1.60 5 1.00 9 1.80
Crear aplicaciones 0.20 7 1.40 6 1.20 9 1.80
Escritura de
archivos 0.05 7 0.35 7 0.35 10 0.50
Compatibilidad
con otros
programas
0.10 5 0.50 5 0.50 9 0.90
TOTAL 1.00 7.45 6.05 9.30
30
Proyecto Integrador Scortechini
En base a los resultados anteriores, el lenguaje de programación seleccionado para
realizar la tarea de programación fue Python.
El lenguaje Python
Python es más fácil de usar que otros lenguajes de programación, está disponible
para sistemas operativos Windows, Mac OS X y Unix, y ayuda a realizar tareas
velozmente.
Python es fácil de usar, y ofrece mucha mayor estructura y soporte para programas
grandes que lo que lo que pueden ofrecer los códigos de C++ o archivos por lotes.
Por otro lado, siendo un lenguaje de muy alto nivel, Python tiene tipos de datos de
alto nivel incorporados como arreglos de tamaño flexible y diccionarios. Debido a sus
tipos de datos más generales Python puede aplicarse a un dominio de problemas
mayor que C++ o incluso FORTRAN, y aun así muchas cosas siguen siendo al
menos igual de fácil en Python que en esos lenguajes (Lutz, 2009).
Python permite separar un programa en módulos que pueden reutilizarse en otros
programas en Python. Viene con una gran colección de módulos estándar que se
pueden usar como base de programas, o como ejemplos para empezar a aprender a
programar en Python. Algunos de estos módulos proveen funcionalidades como:
entrada/salida a archivos, llamadas al sistema, e incluso interfaces a sistemas de
interfaz gráfica de usuario como Tk o wxPython (van Rossum, 2009).
Python es un lenguaje interpretado, lo cual permite ahorrar mucho tiempo durante el
desarrollo ya que no es necesario compilar el código ni enlazar librerías. El intérprete
puede usarse interactivamente, lo que facilita experimentar con características del
lenguaje, escribir programas descartables, o probar funciones cuando se hace
desarrollo de programas de abajo hacia arriba (estrategia Top-Down, entiéndase
programación estructurada).
Python permite escribir programas compactos y legibles. Los programas en Python
generalmente son más cortos que sus programas equivalentes en FORTRAN, C++ o
Java por varios motivos:
31
Proyecto Integrador Scortechini
los tipos de datos de alto nivel permiten expresar operaciones complejas en
una sola instrucción.
la agrupación de instrucciones se hace por sangría en vez de apertura y cierre
de llaves.
no es necesario declarar los tipos de dato de las variables lo que permite
cambiar de tipo de dato fácilmente, esto es imposible en otros lenguajes. Los
argumentos de las funciones no tienen que ser obligatorios ya que admite
argumentos opcionales sin declaración explícita.
Python es extensible: si ya se tiene un programa en C++, es fácil agregar una nueva
función o módulo al intérprete de Python, ya sea para realizar operaciones críticas a
velocidad máxima, o para enlazar programas Python con bibliotecas que tal vez sólo
estén disponibles en forma binaria (por ejemplo bibliotecas gráficas específicas de
un fabricante). También es posible enlazar el intérprete de Python a una aplicación
hecha en C++ y usarlo como lenguaje de extensión o de comando para esa
aplicación.
Además Python cuenta con muchas bibliotecas muy útiles para los propósitos de
este proyecto (Lutz, Programming Python, 2011).
La biblioteca NumPy (Numerical Python, Python Numérico) permite realizar cálculos
vectoriales y matriciales de un modo más natural. También tiene funciones de
álgebra lineal, transformada de Fourier, funciones estadísticas y de análisis
matemático y numérico (Idris, 2011) (Idris, NumPy Cookbook, 2012).
Otra biblioteca interesante es SciPy (Scientific Python, Python Científico), que está
basada en NumPy pero permite alcanzar un nivel de programación superior. Posee
funciones matemáticas avanzadas como integración, resolución de ecuaciones
diferenciales ordinarias, ajuste de datos experimentales por varias técnicas,
optimización, etc. (Bressert, 2013).
SymPy (Symbolic Python, Python Simbólico) es una librería para cálculo simbólico.
Constituye un Sistema Computacional de Álgebra (CAS, Computer Algebra System)
completo y al mismo tiempo es más simple, fácil de usar y de extender que otros
programas como MatLab o MathCad. Permite representar variables en forma
simbólica, calcular límites y derivadas, expansión en series de potencias, integración
en forma simbólica (indefinida) y cálculo de integrales (definidas), resolución de
32
Proyecto Integrador Scortechini
ecuaciones diferenciales y algebraicas en varias variables, etc. (Haenel, Gouillart, &
Varoquaux, 2013).
Otras bibliotecas permiten la interacción con otros programas. docx permite escribir y
editar documentos Word. xlwt hace lo mismo con planillas Excel. PDFReport permite
crear archivos PDF. Incluso existen interfaces para AutoCad.
Los párrafos anteriores revelan una ventaja importante del lenguaje Python: todas
esas bibliotecas con funciones ya están definidas y disponibles; además son muy
fáciles de usar. De este modo permite ahorrar mucho tiempo y esfuerzo que supone
el desarrollo de tales herramientas.
Sin embargo presentan la desventaja de ser limitados en algunos aspectos debido a
que están dirigidos a un público científico general y no exclusivamente para
químicos. Otro peligro potencial es que estos módulos fueron desarrollados por
diferentes especialistas para propósitos distintos, por lo tanto no siempre son
compatibles cuando deben trabajar juntos o interactuar.
Bibliografía
Bressert, E. (2013). NumPy and SciPy. Sebastopol: O'Reilly.
Haenel, Gouillart, & Varoquaux. (2013). Python Scientific Lecture Notes. EuroScipy
tutorial team.
Idris, I. (2011). Numpy 1.5 Beginner's Guide. Birmingham: PACKT Publishing Ltd.
Idris, I. (2012). NumPy Cookbook. Birmingham: PACKT Publising Ltd.
Lutz, M. (2009). Learning Python (4° Edición ed.). Sebastopol: O´Reilly.
Lutz, M. (2011). Programming Python. Sebatopol: O'Reilly.
Tarifa, E. E. (2015). Teoría y Modelos de Simulación. Universidad Nacional de Jujuy.
van Rossum, G. (2009). El Tutorial de Python. Python Software Fundation.
33
Proyecto Integrador Scortechini
Capítulo 4: Termodinámica
Introducción
Los cálculos termodinámicos son fundamentales en cualquier proceso industrial para
calcular transferencias de calor, equilibrio de fases, composición de las fases,
transferencia de masa, potencia de bombas, cálculos de equilibrio y otros más. Éstos
tienen incidencia central en el diseño de procesos, economía de los mismos y en su
factibilidad; de ahí su importancia (Himmelblau, 1997).
La selección de los modelos termodinámicos utilizados para modelar gases y
líquidos es de particular interés. Cada modelo resulta apropiado para una
determinada clase de compuestos y de condiciones físicas.
Por ejemplo, la ecuación del gas ideal es ampliamente utilizada tanto para gases
puros como para mezclas gaseosas. Esta ecuación no tiene en cuenta el tamaño
molecular ni el potencial asociado a la energía de interacción molecular. Cuando
cada una de las especies de una mezcla, así como la mezcla misma, siguen la ley
de los gases ideales, se cumplen la ley de Dalton de la aditividad de las presiones
parciales y la ley de Amagat de aditividad de los volúmenes de las especies puras.
El modelo de gas ideal resulta útil para representar sistemas gaseosos a bajas
presiones (menor a 10atm), temperaturas al menos 2,5 veces la crítica y compuestos
no polares o sus mezclas. Puede presentar desviaciones con respecto a los datos
experimentales de hasta un 10% (Henley-Seader, 2000).
La ecuación del Virial es un modelo derivado de la mecánica estadística, es el único
que tiene un fundamento teórico y se aplica para sistemas gaseosos para los que
produce resultados en buen acuerdo con las mediciones experimentales para
densidades de aproximadamente la mitad de la densidad crítica.
Las ecuaciones cúbicas de estado como la de Redlich-Kwong, Soave-Redlich-
Kwong y Peng-Robinson, refinan el término que da cuenta de las interacciones
moleculares. Producen estimaciones aceptables de presión de vapor, densidades y
fugacidades a presiones moderadas (entre 15 y 50atm) tanto para sistemas no
polares como polares, gaseoso o líquidos (Pedersen, 2007).
La solución ideal es adecuada para representar mezclas líquidas de compuestos
isómeros u homólogos o muy diluidos a presiones bajas y moderadas. Cuando se
34
Proyecto Integrador Scortechini
tienen soluciones líquidas que contienen especies polares o que forman puentes de
hidrógeno se pueden utilizar los modelos de Margules, Van Laar o de Wilson. Éstos
reflejan la desviación del comportamiento ideal a través del coeficiente de actividad y
proporcionan resultados más realistas que la solución ideal (Smith, 1997).
Así, puede verse que la selección de modelos termodinámicos debe hacerse
cuidadosamente y en función de la naturaleza química del sistema con que se esté
trabajando. Lo anterior impacta directamente en la precisión de los resultados
obtenidos al calcular entalpías, volúmenes molares, entropías, equilibrios de fases,
entre otros.
Las propiedades mencionadas en el párrafo anterior determinan los requerimientos
de combustibles o energéticos, la extensión de las reacciones químicas, las
dimensiones de los equipos de proceso necesarios, tipos de materiales a utilizar, etc.
Esto a su vez tiene una importante incidencia en la economía de los procesos
industriales y afecta su sustentabilidad económica e interés empresarial (Sifuentes,
2000).
Además, como se muestra a continuación, los cálculos termodinámicos son de
naturaleza compleja, rara vez son directos sino que requieren procesos iterativos de
resolución y también criterios fisicoquímicos para la evaluación de los resultados
obtenidos. Por lo tanto la capacidad de realizar estos cálculos es lo que diferencia a
un simulador de procesos de una mera calculadora o de un programa de cálculo
matemático, y al mismo tiempo le agrega valor como producto.
Propiedades termodinámicas generales
Para una propiedad genérica, M, de una solución se tiene que:
𝑛𝑀 = 𝑀(𝑇,𝑃,𝑛1,…,𝑛𝑁)
𝑑(𝑛𝑀) = [𝜕(𝑛𝑀)
𝜕𝑃]𝑇,𝑛
∙ 𝑑𝑃 + [𝜕(𝑛𝑀)
𝜕𝑇]𝑃,𝑛
∙ 𝑑𝑇 +∑[𝜕(𝑛𝑀)
𝜕𝑛𝑖]𝑇,𝑃,𝑛𝑗
∙ 𝑑𝑛𝑖
𝑁
𝑖=1
Donde n es el número de moles totales del sistema, ni es el número de moles de la
especie “i” y nj el de la especie “j”. P representa a la presión y T a la temperatura.
35
Proyecto Integrador Scortechini
Para el caso particular de la energía de Gibbs y un sistema cerrado, se obtiene la
relación fundamental entre propiedades termodinámicas:
𝑑(𝑛𝐺) = [𝜕(𝑛𝐺)
𝜕𝑃]𝑇,𝑛
∙ 𝑑𝑃 + [𝜕(𝑛𝐺)
𝜕𝑇]𝑃,𝑛
∙ 𝑑𝑇 +∑[𝜕(𝑛𝐺)
𝜕𝑛𝑖]𝑇,𝑃,𝑛𝑗
∙ 𝑑𝑛𝑖
𝑁
𝑖=1
Donde G es la energía de Gibbs molar.
Equivalentemente:
𝑑(𝑛𝐺) = (𝑛𝑉) ∙ 𝑑𝑃 − (𝑛𝑆) ∙ 𝑑𝑇 +∑𝜇𝑖 ∙ 𝑑𝑛𝑖
𝑁
𝑖=1
Aquí V representa al volumen molar, S a la entropía molar y i al potencial químico
de la especie “i”.
De donde surge que:
[𝜕(𝑛𝐺)
𝜕𝑃]𝑇,𝑛
= (𝑛𝑉)
[𝜕(𝑛𝐺)
𝜕𝑇]𝑃,𝑛
= −(𝑛𝑆)
[𝜕(𝑛𝐺)
𝜕𝑛𝑖]𝑇,𝑃,𝑛𝑗
= 𝜇𝑖
Se define además una propiedad molar parcial genérica como:
�̅�𝑖 = [𝜕(𝑛𝑀)
𝜕𝑛𝑖]𝑇,𝑃,𝑛𝑗
Su significado es “el valor de la propiedad molar, M, de la especie ‘i’ tal como existe
en la solución”, el valor de esta propiedad difiere del valor de la correspondiente
propiedad molar de la especie pura debido a la influencia que ejercen los otros
constituyentes de la solución. Entonces surge inmediatamente que:
�̅�𝑖 = [𝜕(𝑛𝐺)
𝜕𝑛𝑖]𝑇,𝑃,𝑛𝑗
= 𝜇𝑖
36
Proyecto Integrador Scortechini
Luego:
𝑑(𝑛𝑀) = 𝑛 ∙ [𝜕𝑀
𝜕𝑃]𝑇,𝑛∙ 𝑑𝑃 + 𝑛 ∙ [
𝜕𝑀
𝜕𝑇]𝑃,𝑛∙ 𝑑𝑇 +∑�̅�𝑖 ∙ 𝑑𝑛𝑖
𝑁
𝑖=1
Con la ayuda de las siguientes relaciones:
𝑑𝑛𝑖 = 𝑥𝑖 ∙ 𝑑𝑛 + 𝑛 ∙ 𝑑𝑥𝑖
𝑑(𝑛𝑀) = 𝑛 ∙ 𝑑𝑀 +𝑀 ∙ 𝑑𝑛
Se llega a
𝑛𝑑𝑀 +𝑀𝑑𝑛 = 𝑛 ∙ [𝜕𝑀
𝜕𝑃]𝑇,𝑥∙ 𝑑𝑃 + 𝑛 ∙ [
𝜕𝑀
𝜕𝑇]𝑃,𝑥∙ 𝑑𝑇 +∑�̅�𝑖 ∙ (𝑥𝑖 ∙ 𝑑𝑛 + 𝑛 ∙ 𝑑𝑥𝑖)
𝑁
𝑖=1
Que equivale a
[𝑑𝑀 − [𝜕𝑀
𝜕𝑃]𝑇,𝑥∙ 𝑑𝑃 − [
𝜕𝑀
𝜕𝑇]𝑃,𝑥∙ 𝑑𝑇 −∑�̅�𝑖 ∙ 𝑑𝑥𝑖
𝑁
𝑖=1
] ∙ 𝑛 + [𝑀 −∑𝑥𝑖 ∙ �̅�𝑖
𝑁
𝑖=1
] ∙ 𝑑𝑛 = 0
La única forma de que se cumpla siempre la igualdad anterior es que ambos
términos sean cero. Por lo tanto:
𝑀 −∑𝑥𝑖 ∙ �̅�𝑖
𝑁
𝑖=1
= 0 ↔ 𝑀 =∑𝑥𝑖 ∙ �̅�𝑖
𝑁
𝑖=1
Esta ecuación se conoce como relación de actividad o principio de adicionabilidad y
es la clave para calcular las propiedades de la solución a partir de las propiedades
molares parciales de sus componentes.
Si ahora la diferenciamos:
𝑑𝑀 =∑𝑥𝑖 ∙ 𝑑�̅�𝑖
𝑁
𝑖=1
+∑�̅�𝑖 ∙ 𝑑𝑥𝑖
𝑁
𝑖=1
Reemplazando en el primer corchete…
∑𝑥𝑖 ∙ 𝑑�̅�𝑖
𝑁
𝑖=1
= [𝜕𝑀
𝜕𝑃]𝑇,𝑥∙ 𝑑𝑃 + [
𝜕𝑀
𝜕𝑇]𝑃,𝑥∙ 𝑑𝑇
37
Proyecto Integrador Scortechini
La ecuación anterior se conoce como la ecuación de Gibbs-Duhem.
Además aplicando la definición de propiedad molar parcial a la relación fundamental
de propiedades se tiene que:
𝑑�̅�𝑖 = [𝜕�̅�𝑖𝜕𝑃]𝑇,𝑥
∙ 𝑑𝑃 + [𝜕�̅�𝑖𝜕𝑇]𝑃,𝑥
∙ 𝑑𝑇 = �̅�𝑖 ∙ 𝑑𝑃 − 𝑆�̅� ∙ 𝑑𝑇
Sistemas ideales
Mezclas de gases ideales
Se define la presión parcial de una especie en una mezcla de gases ideales como:
𝑝𝑖 = 𝑦𝑖 ∙ 𝑃
Donde pi es la presión parcial, yi es la fracción molar de la especie “i” en la mezcla
gaseosa y P es la presión total del sistema.
El Teorema de Gibbs afirma que: “el valor de la propiedad molar parcial de una
especie en una mezcla de gases ideales a temperatura T y presión total P es igual al
valor de la correspondiente propiedad molar de la especie pura como gas ideal a la
misma temperatura que la mezcla y a una presión igual a su presión parcial en la
mezcla”. En símbolos algebraicos:
�̅�𝑖(𝑇,𝑃) = 𝑀𝑖(𝑇,𝑝𝑖)𝑔𝑖
La propiedad no puede ser el volumen.
Entonces:
�̅�𝑖(𝑇,𝑃)𝑔𝑖
= 𝐻𝑖(𝑇,𝑃)𝑔𝑖
�̅�𝑖(𝑇,𝑃)𝑔𝑖
= 𝑈𝑖(𝑇,𝑃)𝑔𝑖
Porque la entalpía, H, y la energía interna, U, de un gas ideal no son funciones de la
presión.
38
Proyecto Integrador Scortechini
𝑆̅𝑖(𝑇,𝑃)𝑔𝑖
= 𝑆𝑖(𝑇,𝑝𝑖)𝑔𝑖
= 𝑆𝑖(𝑇,𝑃)𝑔𝑖
− 𝑅 ∙ 𝑙𝑛(𝑦𝑖)
�̅�𝑖(𝑇,𝑃)𝑔𝑖
= �̅�𝑖(𝑇,𝑃)𝑔𝑖
− 𝑇 ∙ 𝑆̅𝑖(𝑇,𝑃)𝑔𝑖
= 𝐻𝑖(𝑇,𝑃)𝑔𝑖
− 𝑇 ∙ 𝑆𝑖(𝑇,𝑃)𝑔𝑖
+ 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑦𝑖)
Aplicando ahora la relación de actividad a las propiedades anteriores se pueden
calcular las correspondientes propiedades de la mezcla:
𝐻(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
�̅�𝑖(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
𝐻𝑖(𝑇,𝑃)𝑔𝑖
𝑈(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
�̅�𝑖(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
𝑈𝑖(𝑇,𝑃)𝑔𝑖
𝑆(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
𝑆̅𝑖(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
𝑆𝑖(𝑇,𝑃)𝑔𝑖
− 𝑅∑𝑦𝑖 ∙ 𝑙𝑛(𝑦𝑖)
𝑁
𝑖=1
𝐺(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
�̅�𝑖(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
𝐺𝑖(𝑇,𝑃)𝑔𝑖
+ 𝑅 ∙ 𝑇 ∙∑𝑦𝑖 ∙ 𝑙𝑛(𝑦𝑖)
𝑁
𝑖=1
La solución ideal
El equivalente de una mezcla de gases ideales cuando el estado de agregación es
líquido se llama solución ideal. Se define una solución ideal como aquella para la
que:
�̅�𝑖𝑖𝑑 = 𝐺𝑖 + 𝑅 ∙ 𝑇 ∙ ln(𝑥𝑖)
De lo anterior se desprende que:
�̅�𝑖𝑖𝑑 = 𝐻𝑖
�̅�𝑖𝑖𝑑 = 𝑈𝑖
�̅�𝑖𝑖𝑑 = 𝑉𝑖
𝑆�̅�𝑖𝑑 = 𝑆𝑖 − 𝑅 ∙ ln(𝑥𝑖)
39
Proyecto Integrador Scortechini
Donde xi es la fracción molar de la especie “i” en la mezcla líquida. Estas ecuaciones
permiten calcular las propiedades molares de las especies tal como existen en la
mezcla líquida.
Aplicando el principio de actividad podemos calcular las respectivas propiedades de
la solución a partir de las propiedades parciales de sus componentes:
𝐻𝑖𝑑 =∑𝑥𝑖 ∙ 𝐻𝑖
𝑁
𝑖=1
𝑈𝑖𝑑 =∑𝑥𝑖 ∙ 𝑈𝑖
𝑁
𝑖=1
𝑆𝑖𝑑 =∑𝑥𝑖 ∙ 𝑆𝑖
𝑁
𝑖=1
− 𝑅 ∙∑𝑥𝑖 ∙ 𝑙𝑛(𝑥𝑖)
𝑁
𝑖=1
𝐺𝑖𝑑 =∑𝑥𝑖 ∙ 𝐺𝑖
𝑁
𝑖=1
+ 𝑅 ∙ 𝑇 ∙∑𝑥𝑖 ∙ 𝑙𝑛(𝑥𝑖)
𝑁
𝑖=1
Sistemas no ideales
Cuando una solución, gaseosa o líquida, está compuesta por especies con
momento dipolar elevado, cuando se forman puentes de hidrógeno o cuando las
fuerzas intermoleculares o la fuerza iónica son considerables, de modo tal que ya no
se puede suponer que cada molécula existe en forma independiente del resto
surgen energías de interacción que modifican los valores de las propiedades dados
por las leyes ideales. Entonces es necesario agregar un término corrector en el
cálculo de cada propiedad para dar cuenta de esta interacción entre las moléculas
de las sustancias que componen la solución. Para mezclas de gases el término
corrector recibe el nombre de propiedad residual, mientras que para soluciones
líquidas se le llama propiedad en exceso.
40
Proyecto Integrador Scortechini
Propiedades Residuales de las Sustancias puras
Cuando la temperatura se mantiene constante, la relación fundamental de
propiedades para una especie pura se reduce a:
𝑑𝐺𝑖𝑔𝑖= 𝑉𝑖
𝑔𝑖∙ 𝑑𝑃(𝑇 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒)
Como para los gases ideales vale que:
𝑃 ∙ 𝑉𝑔𝑖 = 𝑅 ∙ 𝑇
Entonces:
𝑑𝐺𝑖𝑔𝑖= 𝑅 ∙ 𝑇 ∙
𝑑𝑃
𝑃= 𝑅 ∙ 𝑇 ∙ 𝑑(𝑙𝑛𝑃) (𝑇 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒)
De aquí surge que la energía libre de un gas ideal es función de la temperatura y de
la presión. Se puede escribir:
𝐺𝑖𝑔𝑖= Γ(𝑇) + 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑃)
Donde (T) es una función de la temperatura que debe determinarse
experimentalmente.
Cuando la especie “i” se encuentra en una mezcla de gases ideales, se tiene que:
�̅�𝑖(𝑇,𝑃)𝑔𝑖
= 𝐺𝑖𝑔𝑖+ 𝑅 ∙ 𝑇 ∙ ln(𝑦𝑖) = Γ𝑖(𝑇) + 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑦𝑖 ∙ 𝑃)
Para la mezcla de gases ideales:
𝐺(𝑇,𝑃)𝑔𝑖
=∑𝑦𝑖 ∙
𝑁
𝑖=1
Γ𝑖(𝑇) + 𝑅 ∙ 𝑇 ∙∑𝑦𝑖 ∙
𝑁
𝑖=1
𝑙𝑛(𝑦𝑖 ∙ 𝑃)
Para los gases reales existen relaciones análogas:
𝐺𝑖 = Γ𝑖(𝑇) + 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑓𝑖)
Donde fi es la fugacidad de la especie “i” en la mezcla gaseosa. La fugacidad tiene
una ventaja respecto de la presión parcial que se demostrará inmediatamente.
Una propiedad residual se define como la diferencia entre el valor de la propiedad
real y el valor de la propiedad del gas ideal. Para la energía de Gibbs molar:
41
Proyecto Integrador Scortechini
𝐺𝑖𝑅 = 𝐺𝑖 − 𝐺𝑖
𝑔𝑖= 𝑅 ∙ 𝑇 ∙ 𝑙𝑛 (
𝑓𝑖𝑃)
Se define, además, por conveniencia el coeficiente de fugacidad de una especie “i”
en una mezcla gaseosa como:
𝜙𝑖 =𝑓𝑖
𝑓𝑖𝑖𝑑=𝑓𝑖𝑃
Entonces:
𝐺𝑖𝑅 = 𝑅𝑇 ∙ ln 𝜙𝑖
ln𝜙𝑖 = ∫ (𝑍𝑖 − 1) ∙𝑑𝑃
𝑃
𝑃
0
(𝑇 = 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒)
De esta forma se puede calcular el valor del coeficiente de fugacidad a partir de
datos experimentales del factor de compresibilidad, Z, y a partir de aquel la
fugacidad, la energía de Gibbs residual y la real.
Ecuación del Virial
Una ecuación de estado alternativa a la ley de los gases ideales es la ecuación del
Virial que, truncada a dos términos, se define así:
𝑍 = 1 +𝐵 ∙ 𝑃
𝑅 ∙ 𝑇
Donde Z es el factor de compresibilidad y B es el segundo coeficiente Virial. La
ecuación anterior se puede poner en términos de las propiedades reducidas:
𝑍 = 1 + (𝐵 ∙ 𝑃𝑐𝑅 ∙ 𝑇𝑐
) ∙𝑃𝑟𝑇𝑟
El paréntesis se puede modelar como una correlación tipo Pitzer:
𝐵 ∙ 𝑃𝑐𝑅 ∙ 𝑇𝑐
= 𝐵(𝑇𝑟)0 + 𝜔 ∙ 𝐵(𝑇𝑟)
1
Donde B0 y B1 son funciones de la temperatura reducida Tr:
42
Proyecto Integrador Scortechini
𝐵0 = 0.083 −0.422
𝑇𝑟1.6
𝐵1 = 0.139 −0.172
𝑇𝑟4.2
Para una especie pura “i”:
𝑍𝑖 − 1 = 𝐵𝑖0 ∙𝑃𝑟𝑖𝑇𝑟𝑖
+ 𝜔𝑖 ∙ 𝐵𝑖1 ∙𝑃𝑟𝑖𝑇𝑟𝑖
= (𝐵𝑖 ∙ 𝑃𝑖𝑐𝑅 ∙ 𝑇𝑐𝑖
) ∙𝑃𝑟𝑖𝑇𝑟𝑖
=𝐵𝑖 ∙ 𝑃
𝑅 ∙ 𝑇
De la definición del coeficiente de fugacidad se desprende que:
𝑙𝑛𝜙𝑖𝑉𝑖𝑟𝑖𝑎𝑙 =
𝐵𝑖𝑅 ∙ 𝑇
∙ ∫ 𝑑𝑃𝑃
0
= 𝑍𝑖 − 1
A partir de lo anterior se pueden calcular todas las demás propiedades
termodinámicas:
𝐻𝑖𝑅
𝑅𝑇= −𝑇 ∙ [
𝜕𝑙𝑛𝜙𝑖𝑉𝑖𝑟𝑖𝑎𝑙
𝜕𝑇]𝑃,𝑦
=𝑃
𝑅∙ (𝐵𝑖𝑇−𝜕𝐵𝑖𝜕𝑇)
𝑈𝑖𝑅
𝑅𝑇=𝑃
𝑅∙𝜕𝐵𝑖𝜕𝑇
𝑆𝑖𝑅
𝑅= −
𝑃
𝑅∙𝜕𝐵𝑖𝜕𝑇
𝑉𝑖𝑅
𝑅𝑇= [
𝜕𝑙𝑛𝜙𝑖𝑉𝑖𝑟𝑖𝑎𝑙
𝜕𝑃]𝑇,𝑦
=𝐵𝑖𝑅 ∙ 𝑇
Donde:
𝜕𝐵
𝜕𝑇=𝑅
𝑃𝑐∙ (𝑑𝐵0
𝑑𝑇𝑟+ 𝜔 ∙
𝑑𝐵1
𝑑𝑇𝑟)
𝑑𝐵0
𝑑𝑇𝑟=0.6752
𝑇𝑟2.6
𝑑𝐵1
𝑑𝑇𝑟=0.7224
𝑇𝑟5.2
43
Proyecto Integrador Scortechini
Ecuaciones cúbicas de estado
Otro modelo diferente para describir el comportamiento de gases son las ecuaciones
cúbicas de estado. La expresión general de la ecuación cúbica de estado es:
𝑃 =𝑅 ∙ 𝑇
(𝑉 − 𝑏)−
𝑎(𝑇)(𝑉 + 𝜖 ∙ 𝑏) ∙ (𝑉 + 𝜎 ∙ 𝑏)
Donde a(T) y b son:
𝑎(𝑇) = Ψ ∙𝛼(𝑇𝑟) ∙ (𝑅 ∙ 𝑇𝑐)
2
𝑃𝑐
𝑏 = Ω ∙𝑅 ∙ 𝑇𝑐𝑃𝑐
Donde Tr es la temperatura reducida y Pr es la presión reducida. Los símbolos , ,
y son constantes y es una función de la temperatura reducida y del factor
acéntrico, , características de cada ecuación de estado.
Tabla 4. Parámetros de las ecuaciones cúbicas de estado
Ecuación (Tr)
Redlich-Kwong 𝑇𝑟−1 2⁄ 0 1 0.08664 0.42748
Soave-Redlich-
Kwong (SRK) [1 + 𝑓(𝜔) ∙ (1 − 𝑇𝑟
1 2⁄ )]2 0 1 0.08664 0.42748
Peng-Robinson (PR) [1 + 𝑓(𝜔) ∙ (1 − 𝑇𝑟1 2⁄ )]
2 1 − √2 1 + √2 0.07780 0.45724
𝑓𝑆𝑅𝐾(𝜔) = 0.480 + 1.574 ∙ 𝜔 − 0.176 ∙ 𝜔2
𝑓𝑃𝑅(𝜔) = 0.37464 + 1.54226 ∙ 𝜔 − 0.26992 ∙ 𝜔2
A partir de la expresión de la ecuación de estado se pueden obtener expresiones
para el factor de compresibilidad tanto de gases como de líquidos:
𝑍𝑉 = 1 + 𝛽 − 𝑞 ∙ 𝛽 ∙𝑍 − 𝛽
(𝑍 + 𝜖 ∙ 𝑏) ∙ (𝑍 + 𝜎 ∙ 𝑏)
𝑍𝐿 = 𝛽 + (𝑍 + 𝜖 ∙ 𝑏) ∙ (𝑍 + 𝜎 ∙ 𝑏) ∙ (1 + 𝛽 − 𝑍
𝑞 ∙ 𝛽)
44
Proyecto Integrador Scortechini
Donde los supraíndices V y L hacen referencia a las fases vapor y líquido
respectivamente; q y son funciones que se definen a continuación:
𝛽 =𝑏 ∙ 𝑃
𝑅 ∙ 𝑇= Ω ∙
𝑃𝑟𝑇𝑟
𝑞 =𝑎(𝑇)
𝑏 ∙ 𝑅 ∙ 𝑇=Ψ ∙ 𝛼(𝑇𝑟)
Ω ∙ 𝑇𝑟
Con estas relaciones podemos calcular el coeficiente de fugacidad de una especie
pura:
𝑙𝑛𝜙𝑖𝐸𝑂𝑆 = 𝑍𝑖 − 1 − 𝑙𝑛(𝑍𝑖 − 𝛽𝑖) − 𝑞𝑖 ∙ 𝐼𝑖
Donde Ii es:
𝐼𝑖 =1
𝜎 − 𝜖∙ 𝑙𝑛 (
𝑍𝑖 + 𝜎 ∙ 𝛽𝑖𝑍𝑖 + 𝜖 ∙ 𝛽𝑖
)
Luego se pueden calcular todas las propiedades residuales de una especie pura:
𝐺𝑖𝑅
𝑅 ∙ 𝑇= 𝑙𝑛𝜙𝑖
𝐸𝑂𝑆
𝐻𝑖𝑅
𝑅 ∙ 𝑇= 𝑍𝑖 − 1 + [
𝑇
𝛼∙𝑑𝛼
𝑑𝑇− 1] ∙ 𝑞𝑖 ∙ 𝐼𝑖
𝑈𝑖𝑅
𝑅 ∙ 𝑇= [
𝑇
𝛼∙𝑑𝛼
𝑑𝑇− 1] ∙ 𝑞𝑖 ∙ 𝐼𝑖
𝑆𝑖𝑅
𝑅= 𝑙𝑛(𝑍𝑖 − 1) +
𝑇
𝛼∙𝑑𝛼
𝑑𝑇∙ 𝑞𝑖 ∙ 𝐼𝑖
𝑉𝑖𝑅
𝑅 ∙ 𝑇=𝑍𝑖 − 1
𝑃
45
Proyecto Integrador Scortechini
Propiedades Residuales de las Mezclas
Para una mezcla de gases, la energía de Gibbs residual se define como:
𝑛𝐺𝑅 = 𝑛𝐺 − 𝑛𝐺𝑔𝑖
La energía de Gibbs molar parcial de un componente “i” en la mezcla real está dada
por:
�̅�𝑖 = 𝜇𝑖 = Γ𝑖(𝑇) + 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑓𝑖)
Donde 𝑓𝑖 es la fugacidad de la especie “i” tal como existe en la solución real.
Recordemos la misma propiedad para una especie en una mezcla de gases ideales:
�̅�𝑖𝑔𝑖= 𝜇𝑖
𝑔𝑖= Γ𝑖(𝑇) + 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑦𝑖 ∙ 𝑃)
Restando las dos últimas ecuaciones se obtiene la energía de Gibbs molar parcial
residual de la especie “i”:
�̅�𝑖𝑅 = �̅�𝑖 − �̅�𝑖
𝑔𝑖= 𝑅 ∙ 𝑇 ∙ 𝑙𝑛 (
𝑓𝑖𝑦𝑖 ∙ 𝑃
)
Por conveniencia se define el coeficiente de fugacidad de la especie “i” tal como
existe en la mezcla real como:
�̂�𝑖 =𝑓𝑖
𝑦𝑖 ∙ 𝑃
La conveniencia de esta propiedad proviene del hecho que, igual que en el caso de
una especie pura, se puede medir experimentalmente a partir de datos de
compresibilidad:
𝑙𝑛(�̂�𝑖) = ∫ [𝜕(𝑛𝑍 − 𝑛)
𝜕𝑛𝑖]𝑇,𝑃,𝑛𝑗
𝑃
0
∙𝑑𝑃
𝑃= ∫ (�̅�𝑖 − 1)
𝑃
0
∙𝑑𝑃
𝑃
Entonces:
�̅�𝑖𝑅 = 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(�̂�𝑖)
46
Proyecto Integrador Scortechini
Para poder calcular las propiedades residuales, el siguiente paso es escribir la
relación fundamental de propiedades para la mezcla real y para una mezcla de
gases ideales.
𝑑 (𝑛𝐺
𝑅 ∙ 𝑇) =
𝑛𝑉
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑
�̅�𝑖𝑅 ∙ 𝑇
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
𝑑 (𝑛𝐺𝑔𝑖
𝑅 ∙ 𝑇) =
𝑛𝑉𝑔𝑖
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻𝑔𝑖
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑
�̅�𝑖𝑔𝑖
𝑅 ∙ 𝑇
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
Haciendo la diferencia se obtiene la relación fundamental para propiedades
residuales:
𝑑 (𝑛𝐺𝑅
𝑅 ∙ 𝑇) =
𝑛𝑉𝑅
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻𝑅
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑
�̅�𝑖𝑅
𝑅 ∙ 𝑇
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
Reemplazando �̅�𝑖𝑅
𝑅∙𝑇 por 𝑙𝑛(�̂�𝑖):
𝑑 (𝑛𝐺𝑅
𝑅 ∙ 𝑇) =
𝑛𝑉𝑅
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻𝑅
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑𝑙𝑛(�̂�𝑖)
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
Tenemos entonces las siguientes relaciones:
�̅�𝑖𝑅
𝑅 ∙ 𝑇= [
𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑃]𝑇,𝑦
�̅�𝑖𝑅
𝑅 ∙ 𝑇= −𝑇 ∙ [
𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑇]𝑃,𝑦
�̅�𝑖𝑅
𝑅 ∙ 𝑇=
�̅�𝑖𝑅
𝑅 ∙ 𝑇− 𝑃 ∙
�̅�𝑖𝑅
𝑅 ∙ 𝑇= −𝑇 ∙ [
𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑇]𝑃,𝑦
− 𝑃 ∙ [𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑃]𝑇,𝑦
𝑆�̅�𝑅
𝑅=
�̅�𝑖𝑅
𝑅 ∙ 𝑇−�̅�𝑖𝑅
𝑅 ∙ 𝑇= −𝑇 ∙ [
𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑇]𝑃,𝑦
− 𝑙𝑛(�̂�𝑖)
Aplicando ahora el principio de actividad podemos calcular todas las propiedades
residuales de la mezcla:
47
Proyecto Integrador Scortechini
𝐺𝑅
𝑅 ∙ 𝑇=∑𝑦𝑖
𝑁
𝑖=1
∙�̅�𝑖𝑅
𝑅 ∙ 𝑇=∑𝑦𝑖
𝑁
𝑖=1
∙ 𝑙𝑛(�̂�𝑖)
𝑉𝑅
𝑅 ∙ 𝑇=∑𝑦𝑖
𝑁
𝑖=1
∙�̅�𝑖𝑅
𝑅 ∙ 𝑇=∑𝑦𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑃]𝑇,𝑦
𝐻𝑅
𝑅 ∙ 𝑇=∑𝑦𝑖
𝑁
𝑖=1
∙�̅�𝑖𝑅
𝑅 ∙ 𝑇= −𝑇 ∙∑𝑦𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑇]𝑃,𝑦
𝑈𝑅
𝑅 ∙ 𝑇=∑𝑦𝑖
𝑁
𝑖=1
∙ (�̅�𝑖𝑅
𝑅 ∙ 𝑇−𝑃 ∙ �̅�𝑖
𝑅
𝑅 ∙ 𝑇) = −𝑇 ∙∑𝑦𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑇]𝑃,𝑦
− 𝑃 ∙∑𝑦𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑃]𝑇,𝑦
𝑆𝑅
𝑅=∑𝑦𝑖
𝑁
𝑖=1
∙ (�̅�𝑖𝑅
𝑅 ∙ 𝑇−�̅�𝑖𝑅
𝑅 ∙ 𝑇) = −𝑇 ∙∑𝑦𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛(�̂�𝑖)
𝜕𝑇]𝑃,𝑦
−∑𝑦𝑖
𝑁
𝑖=1
∙ 𝑙𝑛(�̂�𝑖)
Ecuación del Virial
Cuando adoptamos la ecuación del Virial como modelo para representar a una
mezcla de gases reales, necesitamos definir las siguientes propiedades “cruzadas”
que se obtienen por combinación de las propiedades de los componentes puros:
𝑍𝑐𝑖𝑗 =𝑍𝑐𝑖 + 𝑍𝑐𝑗
2
𝑇𝑐𝑖𝑗 = (𝑇𝑐𝑖 ∙ 𝑇𝑐𝑗)12⁄ ∙ (1 − 𝑘𝑖𝑗)
𝑉𝑐𝑖𝑗 = (𝑉𝑐𝑖1 3⁄ + 𝑉𝑐𝑗
1 3⁄
2)
3
𝑃𝑐𝑖𝑗 =𝑍𝑐𝑖𝑗 ∙ 𝑅 ∙ 𝑇𝑐𝑖𝑗
𝑉𝑐𝑖𝑗
𝜔𝑖𝑗 =𝜔𝑖 + 𝜔𝑗
2
48
Proyecto Integrador Scortechini
Donde los kij son coeficientes de interacción intermolecular que se obtienen a partir
de ajustes de datos experimentales.
La temperatura reducida y la presión reducida cruzadas son entonces:
𝑇𝑟𝑖𝑗 =𝑇
𝑇𝑐𝑖𝑗
𝑃𝑟𝑖𝑗 =𝑃
𝑃𝑐𝑖𝑗
La forma más simple y rápida de calcular las propiedades residuales de la mezcla es
la siguiente. Se define el segundo coeficiente Virial de la mezcla como:
𝐵 =∑∑𝑦𝑖 ∙ 𝑦𝑗 ∙ 𝐵𝑖𝑗
𝑁
𝑗=1
𝑁
𝑖=1
Donde los segundos coeficientes Viriales cruzados, Bij, están dados por:
𝐵𝑖𝑗 =𝑅 ∙ 𝑇𝑐𝑖𝑗
𝑃𝑐𝑖𝑗∙ (𝐵(𝑇𝑟𝑖𝑗)
0 + 𝜔𝑖𝑗 ∙ 𝐵(𝑇𝑟𝑖𝑗)1 )
Las funciones B0 y B1 son las mismas que se definieron anteriormente para la
ecuación del Virial, sólo que esta vez están evaluadas en Trij en vez de Tr.
Y la derivada del segundo coeficiente Virial de la mezcla respecto de la temperatura
es:
𝑑𝐵
𝑑𝑇=∑∑𝑦𝑖 ∙ 𝑦𝑗 ∙
𝑑𝐵𝑖𝑗
𝑑𝑇
𝑁
𝑗=1
𝑁
𝑖=1
Donde:
𝑑𝐵𝑖𝑗
𝑑𝑇=
𝑅
𝑃𝑐𝑖𝑗∙ (𝑑𝐵(𝑇𝑟𝑖𝑗)
0
𝑑𝑇𝑟𝑖𝑗+𝜔𝑖𝑗 ∙
𝑑𝐵(𝑇𝑟𝑖𝑗)1
𝑑𝑇𝑟𝑖𝑗)
Nuevamente las derivadas de B0 y de B1 respecto de la temperatura reducida las
mismas que definieron antes, sólo que ahora se evalúan en la Trij.
49
Proyecto Integrador Scortechini
Entonces, las propiedades residuales de la mezcla son:
𝐺𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅 ∙ 𝑇=𝐵 ∙ 𝑃
𝑅 ∙ 𝑇
𝐻𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅 ∙ 𝑇=𝑃
𝑅∙ (𝐵
𝑇−𝑑𝐵
𝑑𝑇)
𝑉𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅 ∙ 𝑇=
𝐵
𝑅 ∙ 𝑇
𝑈𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅 ∙ 𝑇=𝐻𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅 ∙ 𝑇−𝑃 ∙ 𝑉𝑉𝑖𝑟𝑖𝑎𝑙
𝑅
𝑅 ∙ 𝑇= −
𝑃
𝑅∙𝑑𝐵
𝑑𝑇
𝑆𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅=𝐻𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅 ∙ 𝑇−𝐺𝑉𝑖𝑟𝑖𝑎𝑙𝑅
𝑅 ∙ 𝑇= −
𝑃
𝑅∙𝑑𝐵
𝑑𝑇
Para los cálculos de equilibrio líquido-vapor son de interés los coeficientes de
actividad de las especies en solución. Éstos se pueden obtener con la siguiente
fórmula:
𝑙𝑛�̂�𝑘 =𝑃
𝑅 ∙ 𝑇∙ [𝐵𝑘𝑘 +
1
2∙∑∑𝑦𝑖 ∙ 𝑦𝑗 ∙ (2𝛿𝑖𝑘 − 𝛿𝑖𝑗)
𝑁
𝑗=1
𝑁
𝑖=1
]
Donde:
𝛿𝑖𝑗 = 2 ∙ 𝐵𝑖𝑗 − 𝐵𝑖𝑖 − 𝐵𝑗𝑗
Ecuaciones cúbicas de estado
Para que las ecuaciones de estado se puedan aplicar a una mezcla es necesario
definir el parámetro cruzado:
𝑎𝑖𝑗 = √𝑎𝑖 ∙ 𝑎𝑗 ∙ (1 − 𝑘𝑖𝑗)
Los parámetros a y b de la mezcla se definen así:
𝑎 =∑∑𝑦𝑖 ∙ 𝑦𝑗 ∙ 𝑎𝑖𝑗
𝑁
𝑗=1
𝑁
𝑖=1
50
Proyecto Integrador Scortechini
𝑏 =∑𝑦𝑖 ∙ 𝑏𝑖
𝑁
𝑖=1
Los parámetros , q, ZV ZL e I de la mezcla se definen igual que para una sustancia
pura, pero en función de los parámetros de la mezcla.
Además se definen los parámetros molares parciales como:
�̅�𝑖 = 2 ∙ √𝑎𝑖 ∙∑𝑦𝑗 ∙ √𝑎𝑗 ∙ (1 − 𝑘𝑖𝑗)
𝑁
𝑗=1
�̅�𝑖 = 𝑏𝑖
�̅�𝑖 = 𝑞 ∙ (�̅�𝑖𝑎−�̅�𝑖𝑏)
El coeficiente de fugacidad de una especia tal como existe en solución es:
𝑙𝑛�̂�𝑖𝐸𝑂𝑆 =
𝑏𝑖𝑏∙ (𝑍 − 1) − 𝑙𝑛(𝑍 − 𝛽) − �̅�𝑖 ∙ 𝐼
Entonces con estas relaciones podemos calcular todas las propiedades residuales
de la mezcla:
𝐺𝑅
𝑅 ∙ 𝑇=∑𝑦𝑖 ∙
𝑁
𝑖=1
𝑙𝑛�̂�𝑖
𝐻𝑅
𝑅 ∙ 𝑇= 𝑍 − 1 + 𝑇 ∙
𝜕𝑞
𝜕𝑇∙ 𝐼
𝑆𝑅
𝑅= 𝑙𝑛(𝑍 − 𝛽) + [𝑞 + 𝑇 ∙
𝜕𝑞
𝜕𝑇] ∙ 𝐼
𝑉𝑅
𝑅 ∙ 𝑇=(𝑍 − 1)
𝑃
𝑈𝑅
𝑅 ∙ 𝑇=
𝐻𝑅
𝑅 ∙ 𝑇−𝑃 ∙ 𝑉𝑅
𝑅 ∙ 𝑇= 𝑇 ∙
𝜕𝑞
𝜕𝑇∙ 𝐼
Donde:
𝜕𝑞
𝜕𝑇= 𝑞 ∙ (
1
𝑎∙𝜕𝑎
𝜕𝑇−1
𝑇)
51
Proyecto Integrador Scortechini
𝜕𝑎
𝜕𝑇=∑∑𝑦𝑖 ∙ 𝑦𝑗 ∙
𝜕𝑎𝑖𝑗
𝜕𝑇
𝑁
𝑗=1
𝑁
𝑖=1
𝜕𝑎𝑖𝑗
𝜕𝑇= (𝑎𝑗 ∙
𝜕𝑎𝑖𝜕𝑇
+ 𝑎𝑖 ∙𝜕𝑎𝑗
𝜕𝑇) 2 ∙ 𝑎𝑖𝑗⁄
𝜕𝑎𝑖𝜕𝑇
=𝑎𝑖𝛼𝑖∙𝜕𝛼𝑖𝜕𝑇
𝜕𝛼𝑖𝜕𝑇
= −√𝑇𝑟𝑖𝑇
∙ 𝑓(𝜔𝑖) ∙ √𝛼𝑖
Propiedades en Exceso de las Mezclas líquidas
Las propiedades en exceso marcan el grado de apartamiento de una solución líquida
real respecto de la solución ideal. Entonces se definen como la diferencia entre el
valor de la propiedad para la solución real en estado líquido y el valor de la misma
propiedad para la solución ideal en las mismas condiciones de presión y
temperatura. Para una propiedad genérica M:
𝑀𝐸 = 𝑀 −𝑀𝑖𝑑
Si se deriva la ecuación anterior respecto del número de moles de una especie “i”,
obtenemos una ecuación análoga para las propiedades molares parciales en
exceso:
�̅�𝑖𝐸 = �̅�𝑖 − �̅�𝑖
𝑖𝑑
Las propiedades en exceso están relacionadas con las propiedades residuales de la
mezcla y de las especies puras de la siguiente manera:
𝑀𝐸 = 𝑀𝑅 −∑𝑥𝑖 ∙ 𝑀𝑖𝑅
𝑁
𝑖=1
Es interesante destacar que las propiedades en exceso sólo tienen sentido para las
soluciones, pero no para las especies puras, a diferencia de las propiedades
residuales (Smith, 1997).
52
Proyecto Integrador Scortechini
Aplicadas a la energía de Gibbs molar, las ecuaciones anteriores se escriben:
𝐺𝐸 = 𝐺 − 𝐺𝑖𝑑
�̅�𝑖𝐸 = �̅�𝑖 − �̅�𝑖
𝑖𝑑
Donde:
�̅�𝑖 = Γ𝑖(𝑇) + 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑓𝑖)
�̅�𝑖𝑖𝑑 = Γ𝑖(𝑇) + 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑥𝑖 ∙ 𝑓𝑖)
Entonces:
�̅�𝑖𝐸 = 𝑅 ∙ 𝑇 ∙ 𝑙𝑛 (
𝑓𝑖𝑥𝑖 ∙ 𝑓𝑖
)
𝑓𝑖 es la fugacidad de la especie “i” en la mezcla líquida, mientras que f i es la
fugacidad de la especie “i” pura al estado líquido.
Por conveniencia se define el coeficiente de actividad de la especie “i” en solución
como:
𝛾𝑖 =𝑓𝑖
𝑥𝑖 ∙ 𝑓𝑖
Luego:
�̅�𝑖𝐸 = 𝑅 ∙ 𝑇 ∙ 𝑙𝑛𝛾𝑖
El mismo procedimiento se puede aplicar a la relación fundamental de propiedades.
𝑑 (𝑛𝐺
𝑅 ∙ 𝑇) =
𝑛𝑉
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑
�̅�𝑖𝑅 ∙ 𝑇
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
𝑑 (𝑛𝐺𝑖𝑑
𝑅 ∙ 𝑇) =
𝑛𝑉𝑖𝑑
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻𝑖𝑑
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑
�̅�𝑖𝑖𝑑
𝑅 ∙ 𝑇
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
𝑑 (𝑛𝐺𝐸
𝑅 ∙ 𝑇) =
𝑛𝑉𝐸
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻𝐸
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑
�̅�𝑖𝐸
𝑅 ∙ 𝑇
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
53
Proyecto Integrador Scortechini
𝑑 (𝑛𝐺𝐸
𝑅 ∙ 𝑇) =
𝑛𝑉𝐸
𝑅 ∙ 𝑇∙ 𝑑𝑃 −
𝑛𝐻𝐸
𝑅 ∙ 𝑇2∙ 𝑑𝑇 +∑𝑙𝑛𝛾𝑖
𝑁
𝑖=1
∙ 𝑑𝑛𝑖
De las ecuaciones anteriores se desprenden las siguientes relaciones:
�̅�𝑖𝐸
𝑅 ∙ 𝑇= 𝑙𝑛𝛾𝑖
�̅�𝑖𝐸
𝑅 ∙ 𝑇= −𝑇 ∙ [
𝜕𝑙𝑛𝛾𝑖𝜕𝑇
]𝑃,𝑥
�̅�𝑖𝐸
𝑅 ∙ 𝑇= [
𝜕𝑙𝑛𝛾𝑖𝜕𝑃
]𝑇,𝑥
�̅�𝑖𝐸
𝑅 ∙ 𝑇=
�̅�𝑖𝐸
𝑅 ∙ 𝑇−𝑃 ∙ �̅�𝑖
𝐸
𝑅 ∙ 𝑇= −𝑇 ∙ [
𝜕𝑙𝑛𝛾𝑖𝜕𝑇
]𝑃,𝑥− 𝑃 ∙ [
𝜕𝑙𝑛𝛾𝑖𝜕𝑃
]𝑇,𝑥
𝑆�̅�𝐸
𝑅 ∙ 𝑇=
�̅�𝑖𝐸
𝑅 ∙ 𝑇−�̅�𝑖𝐸
𝑅 ∙ 𝑇= −𝑇 ∙ [
𝜕𝑙𝑛𝛾𝑖𝜕𝑇
]𝑃,𝑥− 𝑙𝑛𝛾𝑖
Aplicando, ahora el principio de actividad podemos calcular todas las propiedades en
exceso de la solución líquida:
𝐺𝐸
𝑅 ∙ 𝑇=∑𝑥𝑖
𝑁
𝑖=1
∙�̅�𝑖𝐸
𝑅 ∙ 𝑇=∑𝑥𝑖
𝑁
𝑖=1
∙ 𝑙𝑛𝛾𝑖
𝑉𝐸
𝑅 ∙ 𝑇=∑𝑥𝑖
𝑁
𝑖=1
∙�̅�𝑖𝐸
𝑅 ∙ 𝑇=∑𝑥𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛𝛾𝑖𝜕𝑃
]𝑇,𝑥
𝐻𝐸
𝑅 ∙ 𝑇=∑𝑥𝑖
𝑁
𝑖=1
∙�̅�𝑖𝐸
𝑅 ∙ 𝑇= −𝑇 ∙∑𝑥𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛𝛾𝑖𝜕𝑇
]𝑃,𝑥
𝑈𝐸
𝑅 ∙ 𝑇=∑𝑥𝑖
𝑁
𝑖=1
∙ (�̅�𝑖𝐸
𝑅 ∙ 𝑇−𝑃 ∙ �̅�𝑖
𝐸
𝑅 ∙ 𝑇) = −𝑇 ∙∑𝑥𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛𝛾𝑖𝜕𝑇
]𝑃,𝑥− 𝑃 ∙∑𝑥𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛𝛾𝑖𝜕𝑃
]𝑇,𝑥
𝑆𝐸
𝑅=∑𝑥𝑖
𝑁
𝑖=1
∙ (�̅�𝑖𝐸
𝑅 ∙ 𝑇−�̅�𝑖𝐸
𝑅 ∙ 𝑇) = −𝑇 ∙∑𝑥𝑖
𝑁
𝑖=1
∙ [𝜕𝑙𝑛𝛾𝑖𝜕𝑇
]𝑃,𝑥−∑𝑥𝑖
𝑁
𝑖=1
∙ 𝑙𝑛𝛾𝑖
54
Proyecto Integrador Scortechini
Ecuación de Margules
La ecuación de Margules escrita para un sistema multicomponente proporciona una
expresión para el coeficiente de actividad (Oliver, 1968).
𝑙𝑛𝛾𝑖 = [2𝑥𝑖∑𝑥𝑗𝐴𝑗𝑖
𝑁
𝑗=1
] + [∑𝑥𝑗2𝐴𝑖𝑗
𝑁
𝑗=1
] +
[ ∑∑𝑥𝑗𝑥𝑘𝐴𝑖𝑗𝑘
𝑁
𝑘=2
𝑁
𝑗=1
𝑖 ≠ 𝑗𝑖 ≠ 𝑘𝑗 < 𝑘 ]
− [2∑{𝑥𝑙2∑𝑥𝑗𝐴𝑗𝑙
𝑁
𝑗=1
}
𝑁
𝑙=1
]
− 2
[ ∑∑∑𝑥𝑙𝑥𝑗𝑥𝑘𝐴𝑙𝑗𝑘
𝑁
𝑘=3
𝑁
𝑗=2
𝑁
𝑙=1
𝑙 ≠ 𝑗𝑙 ≠ 𝑘𝑗 < 𝑘 ]
Donde los Aij son los coeficientes de Margules y los Aijk son los parámetros de
interacción terciaria que se calculan a partir de los anteriores con la siguiente
fórmula:
𝐴𝑖𝑗𝑘 =1
2(𝐴𝑖𝑗 + 𝐴𝑗𝑖 + 𝐴𝑖𝑘 + 𝐴𝑘𝑖 + 𝐴𝑗𝑘 + 𝐴𝑘𝑗)
En ausencia de datos experimentales los parámetros binarios se pueden calcular a
partir de los coeficientes de actividad a dilución infinita para sistemas binarios.
𝐴𝑖𝑗 = 𝑙𝑛𝛾𝑖∞
𝐴𝑗𝑖 = 𝑙𝑛𝛾𝑗∞
Desafortunadamente los coeficientes de la ecuación de Margules generalmente se
consideran como constantes, a falta de correlaciones adecuadas que proporcionen
sus valores como función de la presión y de la temperatura, por lo tanto sus
derivadas respecto de la presión o de la temperatura son nulas y la ecuación no
sirve para calcular entalpías y volúmenes en exceso. Sólo sirve para calcular los
coeficientes de actividad y, en base al principio de actividad, la energía de Gibbs
molar en exceso.
Para calcular las demás propiedades en exceso se puede recurrir a la relación entre
las propiedades residuales de la solución y las de los compuestos puros:
55
Proyecto Integrador Scortechini
𝑀𝐸 = 𝑀𝑅 −∑𝑥𝑖 ∙ 𝑀𝑖𝑅
𝑁
𝑖01
Ecuación de Van Laar
La ecuación de Van Laar para un sistema multicomponente provee una expresión
para calcular los coeficientes de actividad de las especies:
𝑙𝑛𝛾𝑖 =∑ 𝑥𝑗𝐴𝑖𝑗𝑁𝑗=1
1 − 𝑥𝑖∙ [
(1 − 𝑥𝑖)∑ 𝑥𝑗𝐴𝑗𝑖𝑁𝑗=1
𝑥𝑖 ∑ 𝑥𝑗𝐴𝑖𝑗𝑁𝑗=1 + (1 − 𝑥𝑖)∑ 𝑥𝑗𝐴𝑗𝑖
𝑁𝑗=1
]
2
Donde los Aij son los parámetros de la ecuación de Van Laar y son funciones de la
temperatura (Henley-Seader, 2000):
𝐴𝑖𝑗 =𝐴𝑖𝑗′
𝑅𝑇
𝐴𝑖𝑗′ se considera constante a presión constante. Entonces la derivada respecto de la
temperatura de los coeficientes es:
𝑑𝐴𝑖𝑗
𝑑𝑇= −
𝐴𝑖𝑗′
𝑅𝑇2= −
𝐴𝑖𝑗
𝑇
Luego:
�̅�𝑖𝐸
𝑅 ∙ 𝑇= −𝑇 ∙ (
𝜕𝑙𝑛𝛾𝑖𝜕𝑇
|𝑃,𝑥
= [∑ 𝑥𝑗𝐴𝑖𝑗𝑁𝑗=1
1 − 𝑥𝑖]
2
− 2 ∙ [(1 − 𝑥𝑖)∑ 𝑥𝑗(𝐴𝑖𝑗 − 𝐴𝑗𝑖)
𝑁𝑗=1
𝑥𝑖 ∑ 𝑥𝑗𝐴𝑖𝑗𝑁𝑗=1 + (1 − 𝑥𝑖)∑ 𝑥𝑗𝐴𝑗𝑖
𝑁𝑗=1
] ∙ 𝑙𝑛𝛾𝑖
Y a partir del principio de actividad se puede calcular la entalpía en exceso de la
solución.
Para calcular el volumen en exceso es necesario recurrir a la misma relación que en
la sección anterior.
En ausencia de datos más precisos los coeficientes de Van Laar pueden calcularse
a partir de los coeficientes de actividad a dilución infinita de sistemas binarios. La
fórmula es la misma que para la ecuación de Margules.
56
Proyecto Integrador Scortechini
Ecuación de Wilson
La ecuación de Wilson proporciona el coeficiente de actividad para una mezcla
líquida multicomponente:
𝑙𝑛𝛾𝑘 = 1 − 𝑙𝑛 [∑𝑥𝑗Λ𝑘𝑗
𝑁
𝑗=1
] −∑[𝑥𝑖Λ𝑖𝑘
∑ 𝑥𝑗Λ𝑖𝑗𝑁𝑗=1
]
𝑁
𝑖=1
Donde los ij son los coeficientes de Wilson que son una función exponencial de la
temperatura:
Λ𝑖𝑗 =𝑉𝑗
𝑉𝑖∙ 𝑒
−(𝜆𝑖𝑗−𝜆𝑖𝑖)
𝑅𝑇
Vi y Vj son los volúmenes molares de las especies “i” y “j” a la misma temperatura
que la mezcla (Henley-Seader, 2000).
La derivada de los coeficientes de Wilson respecto de la temperatura está dada por:
𝑑Λ𝑖𝑗
𝑑𝑇=(𝜆𝑖𝑗 − 𝜆𝑖𝑖)
𝑅𝑇2∙ Λ𝑖𝑗
Entonces la entalpía molar parcial en exceso de la especie “k” se calcula con la
siguiente fórmula:
�̅�𝑘𝐸
𝑅 ∙ 𝑇= −𝑇 ∙ (
𝜕𝑙𝑛𝛾𝑘𝜕𝑇
|𝑃,𝑥
= [∑ 𝑥𝑗(𝜆𝑘𝑗 − 𝜆𝑘𝑘)Λ𝑘𝑗𝑁𝑗=1
𝑅𝑇 ∙ ∑ 𝑥𝑗Λ𝑘𝑗𝑁𝑗=1
] +∑[𝑥𝑖 ∙ Λ𝑖𝑘 ∙ ∑ 𝑥𝑗(𝜆𝑖𝑘 − 𝜆𝑖𝑗)Λ𝑖𝑗
𝑁𝑗=1
𝑅𝑇 ∙ (∑ 𝑥𝑗Λ𝑖𝑗𝑁𝑗=1 )
2 ]
𝑁
𝑖=1
Luego con el principio de actividad se puede calcular la entalpía en exceso, pero no
el volumen en exceso. Para calcular éste último hay que utilizar la relación entre las
propiedades residuales de la mezcla y de los compuestos puros.
A falta de mejores datos, los coeficientes de Wilson se pueden obtener a partir de los
coeficientes de actividad a dilución infinita de sistemas binarios:
𝑙𝑛𝛾𝑖∞ = −𝑙𝑛Λ𝑖𝑗 + 1 − Λ𝑗𝑖
𝑙𝑛𝛾𝑗∞ = −𝑙𝑛Λ𝑗𝑖 + 1 − Λ𝑖𝑗
Pero como estas expresiones no son explícitas se debe recurrir a un procedimiento
iterativo de resolución.
57
Proyecto Integrador Scortechini
Biblioteca de Funciones Termodinámicas
Se trata de un módulo que contiene la definición de varias clases. Esas clases tienen
atributos (propiedades características) y métodos (funciones) característicos de cada
modelo termodinámico.
Las clases que integran la librería son:
Ideal: calcula entalpía, entropía, energía de Gibbs, energía de Helmholtz,
energía interna y volumen molar para mezclas de gases ideales y soluciones
ideales.
Virial: calcula el segundo coeficiente Virial, el factor de compresibilidad,
coeficientes de fugacidad, entalpía, entropía, energía de Gibbs, energía de
Helmholtz, energía interna y volumen residuales para mezclas de gases o en
exceso para mezclas líquidas.
EOS: calcula los parámetros de las ecuaciones de estado, el factor de
compresibilidad, coeficientes de fugacidad, entalpía, entropía, energía de
Gibbs, energía de Helmholtz, energía interna y volumen residuales para
mezclas de gases o en exceso para mezclas líquidas.
Margules: contiene métodos para calcular el coeficiente de actividad de todas
las especies en una mezcla de líquidos según el modelo de Margules.
Van Laar: contiene métodos para calcular el coeficiente de actividad de todas
las especies en una mezcla de líquidos según el modelo de Van Laar.
Wilson: contiene métodos para calcular el coeficiente de actividad de todas
las especies en una mezcla de líquidos según el modelo de Wilson.
SistemaTermodinamico: Esta clase hace uso de todas las anteriores.
Contiene el método “CalcularComposicion” que se encarga de calcular las
fracciones en peso a partir de las fracciones molares, si se trabaja con
caudales molares o las fracciones molares en base a las fracciones en peso si
se trabaja con caudales másicos; también calcula el peso molecular medio de
la mezcla. El método “CalcularPropiedades1” se encarga de calcular el punto
de burbuja, el punto de rocío y de determinar el estado de agregación del
sistema. “CalcularPropiedades2” es una función que calcula los valores de
entalpía, entropía, función de Gibbs, energía interna, volumen molar y función
de Helmholtz para el sistema. Para eso, descompone a cada propiedad como
58
Proyecto Integrador Scortechini
la suma de dos términos: ideal y corrector. El término ideal se calcula creando
un objeto de la clase “Ideal”, que realiza los cálculos y devuelve los
resultados. Si el estado de agregación es gas el término corrector son las
propiedades residuales; si el estado es líquido, el término corrector
corresponde a las propiedades en exceso. Así, de acuerdo al estado de
agregación del sistema y al modelo termodinámico elegido para representar
esa fase, crea un objeto de la clase apropiada (Ideal, Virial, EOS, Margules,
etc.), le envía los parámetros que éste necesite y le solicita que calcule las
residuales o en exceso. Una vez que se dispone de ambos término, se realiza
la suma y se obtiene el valor de las propiedades de la mezcla real. Si el
sistema existe en un equilibrio líquido vapor, primero realiza un cálculo flash
para determinar la proporción de cada fase y su composición, luego se
realizan los cálculos pertinentes para cada fase y después se suman los
resultados multiplicados por una fracción (fracción de vapor para la fase vapor
y fracción de líquido, uno menos la fracción de vapor, para la fase líquida).
Más adelante se desarrollan los detalles de programación relacionados con este
tema.
59
Proyecto Integrador Scortechini
Bibliografía
Henley-Seader. (2000). Operaciones de Separación por Etapas en Ingeniería
Química. México D.F.: Editorial Reverté S.A.
Himmelblau, D. M. (1997). Principios Básicos y Cálculos en Ingeniería Química.
México D.F.: Prentice Hall.
Oliver, E. D. (1968). Industrial & Engineering Chemistry Fundamentals.
Pedersen, C. (2007). Phase Behavior of Petroleum Reservoir Fluids. Taylor &
Francis Group.
Scenna, N. J. (1999). Modelado, Simulación y Optimización de Procesos Químicos.
Sifuentes, M. (2000). Simulación de Procesos en Ingeniería Químicia. México D.F.:
Plaza y Valdés Editores.
Smith. (1997). Introducción a la Termodinámica en Ingeniería Química (5° Edición
ed.). México D.F.: McGraw Hill.
60
Proyecto Integrador Scortechini
Capítulo 5: Objetos Desarrollados
Introducción
En el presente capítulo se presentarán los objetos creados que componen el
simulador de procesos. En cada caso se explicará la función que cumple el
componente, los aspectos técnicos de Ingeniería Química y aquellos detalles
informáticos que se consideren de interés.
La clase Pantalla
La pantalla es uno de los componentes más importantes porque es el principal
elemento de comunicación con el usuario y el primero con el que éste hace contacto.
Desde la pantalla principal se controla el funcionamiento global del proceso a
simular. La siguiente figura muestra una imagen de una pantalla típica.
Figura 6. Pantalla del simulador.
Para crear la pantalla se diseñó una clase llamada Pantalla. Ésta hereda de cuatro
superclases y tiene dos métodos.
61
Proyecto Integrador Scortechini
Las superclases de Pantalla son:
wx.Frame: Esta clase contiene una serie de variables y funciones que
permiten construir automáticamente una pantalla vacía y algunos métodos
que implementan comportamientos básicos.
Métodos: Es una clase que contiene a todas las funciones que determinan el
comportamiento de las funciones que cumple la pantalla. Por ejemplo: las
funciones que responden a la selección de distintos menús o herramientas
como crear un nuevo proyecto, abrir un proceso guardado, guardar los
cambios, agregar un equipo nuevo, etc. También funciones que permiten
mover los íconos por la pantalla, otras que codifican la creación de menús
contextuales (o emergentes, también llamados “pop-up”).
Menus: Contiene un método que devuelve una estructura de datos que
establece el nombre de cada uno de los menús que se mostrarán en la barra
de menú, nombres de los submenús de cada uno, los íconos de cada
submenú, el método con que se debe responder ante la selección del menú, y
el texto a desplegar en la barra de estado cuando se selecciona alguno de
ellos. Otro método se encarga de crear los menús y submenús en base a la
información provista por el método anterior. La última función es la
responsable de crear la barra de menú, de agregarle los menús creados y de
asignar la barra de menú al objeto Pantalla.
BarraH: Es una clase similar a Menus, sólo que se encarga de crea la barra
de herramientas. Como ésta es un poco más simple que una barra de menús,
posee menos métodos. El primero de ellos devuelve una estructura de datos
que proporciona el nombre de cada herramienta, el método al que se debe
llamar en caso de que se seleccione la herramienta y el nombre del archivo
donde se encuentra la imagen para crear el ícono a mostrar en la barra. El
otro método crea la barra y cada una de sus herramientas, las agrega a la
barra y luego le asigna la barra de herramientas al objeto de la clase Pantalla.
Los métodos de Pantalla son:
__init__: En general este método se ejecuta automáticamente cada vez que
se crea el objeto que lo contiene y se utiliza para llevar a cabo tareas que se
sabe son necesarias siempre. En el caso de los objetos del tipo Pantalla este
método recibe dos argumentos: uno es un objeto tipo base de datos y otro
62
Proyecto Integrador Scortechini
objeto tipo Proyecto. La base de datos contiene toda la información de las
propiedades fisicoquímicas de 469 compuestos. El objeto de la clase Proyecto
es el que acumulará toda la información relativa al proceso, incluyendo los
equipos que se vayan a crear. El método __init__ crea automáticamente el
marco de la pantalla, el ícono del sistema, la barra de título, las herramientas
básicas (minimizar, maximizar y cerrar) y un panel en blanco. Además define
una serie de diccionarios que sirven de referencia para relacionar los nombres
de los equipos, los botones que representan sus íconos, sus identidades
(números enteros negativos que Python genera automáticamente y usa para
identificar los componentes) y sus tipos (corriente, mezclador, intercambiador
de calor, etc.). Luego construye una ventana con barras de desplazamiento
que será el paño de diseño para representar el diagrama de flujo del proceso
y está contenida en la ventana de la aplicación. Después llama a los métodos
para crear la barra de menú, la de herramientas y la de estado; y centra la
ventana de la aplicación en la pantalla de la computadora. Finalmente da la
instrucción para mostrar la ventana en pantalla, esto parece trivial pero si no
se hiciera, se crearía la pantalla de la aplicación pero no se vería nada en la
pantalla de la computadora.
crearBarraEst: Esta función crea la barra de estado y le asigna el valor inicial
“Listo”.
La clase BaseDeDatos
Esta clase sirve para crear un objeto almacene todas las propiedades físicas
disponibles en la base de datos. El objeto resultante servirá para proveer información
que asista a otras funciones que realizan los cálculos durante del proceso.
La clase BaseDeDatos contiene cuatro métodos:
__init__: En este caso el método __init__ utiliza la función open_workbook de
la biblioteca xlrd para abrir el archivo “BDD.xls” que contiene la base de datos.
Luego se posiciona en la primera hoja del documento y lee el número de filas
y de columnas. También crea listas que almacenan los símbolos de cada
propiedad, las unidades de éstas y los nombres de todos los compuestos
63
Proyecto Integrador Scortechini
disponibles; además construye un diccionario que relaciona el nombre de
cada propiedad y el nombre de cada compuesto con la dirección de la celda
de la planilla que contiene el valor numérico. Después define un atributo para
cada compuesto y le asigna un objeto cuyos atributos son los nombres de las
propiedades y cuyos valores son los valores de las propiedades para ese
compuesto (base de datos por nombre de compuesto). Finalmente crea un
atributo por cada propiedad y le asigna un objeto cuyos atributos son los
nombres de los compuestos y cuyos valores son los valores de la propiedad
para cada compuesto (base de datos por propiedad).
guardar: Esta función sirve para agregar nueva información a la base de datos
(archivo Excel). Dada una lista con los símbolos de las propiedades y otra con
los valores para cada compuesto, busca la dirección de cada par compuesto-
propiedad y escribe el valor correspondiente en esa celda. Luego guarda el
archivo y la información se incorpora permanentemente a la base de datos.
__getitem__: Es un método que sirve para recuperar el valor de un atributo
del objeto. Recibe como argumento el nombre del atributo y, si existe,
devuelve su valor; de lo contrario se produce un error.
__setitem__: Esta función sirve para crear un nuevo atributo del objeto.
Necesita dos parámetros: el nombre del nuevo atributo y su valor; entonces
agrega el atributo con el nombre proporcionado y le asigna el valor provisto.
Los últimos dos métodos cumplen la misma función en cualquier objeto. En el futuro
se hará mención de sus nombres pero no se repetirá su explicación.
La clase Proyecto
Así como la pantalla ayuda a visualizar de forma gráfica el proceso y es la parte
encargada de interactuar con el usuario, el objeto de la clase Proyecto es la
verdadera estructura que almacena toda la información del proceso, incluyendo los
equipos que forman parte de éste.
La diferencia está en que, al cerrar la aplicación, la pantalla y todos los componentes
visuales contenidos en ella son destruidos y no queda evidencia de su existencia. Si
los datos del proceso se almacenaran en el objeto tipo Pantalla, se perderían al
64
Proyecto Integrador Scortechini
cerrar el programa. En cambio el objeto clase Proyecto es un huésped de la pantalla,
que interactúa con ésta, pero que puede sobrevivir después de cerrar la ventana de
la aplicación y, si se guarda en un archivo, permite preservar toda la información
generada. Así cuando se abra nuevamente el programa, es posible abrir el archivo
de datos, recargar toda la información, visualizarla, modificarla, ampliarla, etc.
La clase Proyecto posee cinco métodos:
__init__: Este método recibe como parámetro un objeto de la clase
BaseDeDatos y crea un atributo al que le asigna este parámetro. También
define los atributos: Sistema_Unidades, Tipo_Caudal, Modelo_Gases,
Molelo_Liquido que contiene cadenas de caracteres, inicialmente vacías, que
sirven para especificar: el sistema de unidades, el tipo de caudal, el modelo
utilizado para representar a los gases y a los líquidos respectivamente.
Además se construye una lista vacía que servirá para almacenar los nombres
de los compuestos que intervienen en el proceso, y un diccionario llamado
“Equipos” que contiene como claves a los tipos de equipos que puede simular
el programa (corriente, nodo_divisor, mezclador, tanque_agitado_continuo,
intercambiador_de_calor, flash y destilador) y como valores a diccionarios,
inicialmente vacíos, que servirán para almacenar el nombre de cada equipo y
el objeto correspondiente que contiene su información.
calcularTref: Esta función sirve para establecer la temperatura de referencia
que será utilizada a la hora de realizar cálculos de entalpía, entropía, energía
interna, libre, etc. Si el objeto Proyecto ya tiene definida una lista de
compuestos, y sus propiedades en la base de datos, entonces establece
como temperatura de referencia para cada compuesto su temperatura normal
de ebullición (Geankoplis, 1998). Esto tiene como consecuencia que la
entalpía de mezclas líquidas tendrán valores negativos de entalpía, mientras
que las mezclas gaseosas o mezclas líquido-vapor tendrán entalpías
positivas. Si la lista de compuestos está vacía, entonces no hace nada.
datosActividad: Este método sirve para almacenar los coeficientes de las
ecuaciones de Margules, Van Laar o de Wilson para cada pareja de
compuestos, en caso que el modelo seleccionado por el usuario en la
configuración del sistema para representar a los líquidos no sea la solución
ideal. Para ello, si la lista de compuestos no está vacía y el modelo de líquidos
65
Proyecto Integrador Scortechini
no es la solución ideal, forma todas las combinaciones posibles de dos
compuestos (sistemas binarios), abre el archivo “Actividad.xls” y se posiciona
en la hoja cuyo nombre es igual al modelo de líquido. Para cada pareja, busca
su nombre en la primera columna y, si lo encuentra, lee los valores de los
coeficientes en las columnas siguientes y los almacena en un diccionario; si
no encuentra el nombre del sistema, lo agrega a una lista de datos faltantes
para solicitar posteriormente al usuario que ingrese esos datos a través de un
diálogo. Si la lista de compuestos está vacía, no hace nada.
__getitem__
__setitem__
La clase SistemaTermodinamico
Esta clase se utiliza para calcular todas las propiedades termodinámicas de una
mezcla multicomponente, por ejemplo una corriente de proceso.
Posee una función __init__ que define automáticamente algunas propiedades
características de todo sistema termodinámico. Por ejemplo, el nombre del sistema,
su temperatura, su presión, su composición, etc. Estos valores los recibe de un
equipo de proceso como una corriente y luego los guarda en variables adecuadas.
También crea un documento Word nuevo donde se documentarán todos los cálculos
realizados. Después llama a las funciones: calcularComposicion a la que le envía
como parámetro la composición del sistema; calcularPropiedades1 y
calcularPropiedades2.
La función calcularComposicion tiene como propósito calcular el peso molecular
medio de la mezcla y determinar la composición en masa si la composición está
dada como fracciones molares o la composición molar en caso contrario.
Para eso, si la composición viene dada como fracción molar, se calcula la fracción
en peso mediante la siguiente fórmula:
𝜔𝑖 =𝑧𝑖 ∙ 𝑃𝑀𝑖
∑ 𝑧𝑖 ∙ 𝑃𝑀𝑖𝑁𝑖=1
66
Proyecto Integrador Scortechini
Donde i, zi, PMi y N son la fracción en masa, la fracción molar, el peso molecular
del compuesto “i” y el número de componentes de la mezcla respectivamente.
Además ∑ 𝑧𝑖 ∙ 𝑃𝑀𝑖𝑁𝑖=1 es el peso molecular medio de la mezcla.
Cuando la composición está dada por fracciones en masa, la fracción molar se
calcula mediante:
𝑧𝑖 =𝜔𝑖 𝑃𝑀𝑖⁄
∑ 𝜔𝑖 𝑃𝑀𝑖⁄𝑁𝑖=1
Donde ∑ 𝜔𝑖 𝑃𝑀𝑖⁄𝑁𝑖=1 es el peso molecular medio de la mezcla.
Los pesos moleculares de los componentes del sistema los obtiene de la base de
datos de propiedades.
Cuando se completan estos cálculos, se escribe un párrafo en el documento Word
con el valor del peso molecular medio y se agregan dos tablas: una que muestra la
composición molar y otra que muestra la composición en peso.
La función calcularPropiedades1 tiene por objeto determinar la temperatura de
burbuja, la temperatura de rocío de la mezcla. Para eso llama a las funciones
calcularTbub, calcularTdew y evaluarFase.
La función calcularTbub sirve para determinar la temperatura de burbuja de una
solución a partir de su presión y de su composición molar. Con ese fin implementa el
procedimiento mostrado a continuación (Smith, 1997):
67
Proyecto Integrador Scortechini
Figura 7. Procedimiento para calcular la temperatura de burbuja.
La propiedad i se define como el cociente entre el coeficiente de fugacidad de la
especie “i” en solución y el coeficiente de fugacidad de la especie “i” pura en la
condición de saturación.
Φ𝑖 =�̂�𝑖𝜙𝑖𝑠𝑎𝑡
Los coeficientes de actividad y los de fugacidad se evalúan de acuerdo a los
modelos que haya seleccionado el usuario para representar líquidos y gases. Por
Leer P, {xi}, constantes. Ajustar todas las i=1.
Calcular {Tisat} con la ecuación 𝑇𝑖
𝑠𝑎𝑡 =𝐵𝑖
𝐴𝑖−𝑙𝑛𝑃− 𝐶𝑖.
Calcular 𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 = ∑ 𝑥𝑖 ∙ 𝑇𝑖𝑠𝑎𝑡𝑁
𝑖=1 .
Evaluar {Pisat}, {i}. Elegir una especie “j” de referencia.
Calcular Pjsat con 𝑃𝑗
𝑠𝑎𝑡 =𝑃
∑ (𝑥𝑖∙𝛾𝑖 Φ𝑖⁄ )∙(𝑃𝑖𝑠𝑎𝑡 𝑃𝑗
𝑠𝑎𝑡⁄ )𝑁𝑖=1
.
Calcular Tburbuja con 𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 =𝐵𝑗
𝐴𝑗−𝑙𝑛𝑃𝑗𝑠𝑎𝑡 − 𝐶𝑗.
Fijar tolerancia del error: .
Evaluar {Pisat}.
Calcular {yi} con 𝑦𝑖 =𝑥𝑖∙𝛾𝑖∙𝑃𝑖
𝑠𝑎𝑡
𝑃∙Φ𝑖.
Evaluar {i}, {i}.
Calcular Pjsat.
Volver a evaluar Tburbuja.
¿Es T<?
Guardar Tburbuja, {yi}
No
Sí
68
Proyecto Integrador Scortechini
ejemplo: ecuación de Margules, de Van Laar, de Wilson; ecuación del Virial,
ecuaciones de estado, etc. Además T=|Tburbuja-Tburbuja anterior|
El método calcularTdew determina la temperatura de rocío de una solución a partir
de su presión y de su composición molar. Para ello implementa el procedimiento
mostrado a continuación (Smith, 1997):
Figura 8. Procedimiento para calcular la temperatura de rocío.
Leer P, {yi}, constantes. Ajustar todas las i=1 y todas las i =1.
Calcular {Tisat} con la ecuación 𝑇𝑖
𝑠𝑎𝑡 =𝐵𝑖
𝐴𝑖−𝑙𝑛𝑃− 𝐶𝑖.
Estimar 𝑇𝑟𝑜𝑐í𝑜 = ∑ 𝑦𝑖 ∙ 𝑇𝑖𝑠𝑎𝑡𝑁
𝑖=1 .
Evaluar {Pisat}, {i}. Elegir una especie “j” de referencia.
Calcular Pjsat con 𝑃𝑗
𝑠𝑎𝑡 = 𝑃 ∙ ∑𝑦𝑖∙Φ𝑖
𝛾𝑖∙ (𝑃𝑗𝑠𝑎𝑡
𝑃𝑖𝑠𝑎𝑡)
𝑁𝑖=1 .
Recalcular Trocío con 𝑇𝑟𝑜𝑐í𝑜 =𝐵𝑗
𝐴𝑗−𝑙𝑛𝑃𝑗𝑠𝑎𝑡 − 𝐶𝑗.
Evaluar {Pisat}, {i}. Calcular {xi} con 𝑥𝑖 =
𝑦𝑖∙𝑃∙Φ𝑖
𝛾𝑖∙𝑃𝑖𝑠𝑎𝑡.
Evaluar {i}. Calcular Pjsat y volver a calcular Trocío.
Fijar tolerancia del error: .
Evaluar {Pisat} y {i}.
Calcular {xi} con 𝑥𝑖 =𝑦𝑖∙𝑃∙Φ𝑖
𝛾𝑖∙𝑃𝑖𝑠𝑎𝑡.
Normalizar los valores de xi.
Evaluar {i}
¿Es cada i <?
Recalcular Pjsat y Trocío.
¿Es T<?
Guardar Trocío, {yi}
No
No
Sí
Sí
69
Proyecto Integrador Scortechini
Donde T=|Trocío-Trocío anterior|
La función evaluar fase compara la temperatura del sistema con la temperatura de
burbuja y la temperatura de rocío. Si la temperatura es menor que la temperatura de
burbuja, el sistema se encuentra como líquido subenfriado. Si la temperatura
coincide con el punto de burbuja se trata de un líquido saturado. Si la temperatura es
igual al punto de rocío se trata de un vapor saturado, mientras que si es mayor el
sistema es un gas. El resultado de esta evaluación se almacena como una cadena
de caracteres en el atributo “fase” del sistema.
Si la temperatura del sistema se encuentra entre la temperatura de burbuja y la de
rocío entonces se tiene una mezcla de líquido y vapor. Para resolver esta situación
se invoca a la función “calculoFlash”.
La función “calculoFlash” se basa en el principio de conservación de la masa de las
especies que forman parte del sistema y en el hecho que las corrientes de líquido y
vapor están en equilibrio.
Una corriente con caudal molar de F moles se descompone en una formada por V
moles de vapor y en otra con L moles de líquido, de modo que:
𝐹 = 𝐿 + 𝑉
Se define a la fracción de vapor como la proporción del sistema que forma la fase
vapor, entonces:
𝛽 =𝑉
𝐹
De donde 𝑉 = 𝛽 ∙ 𝐹 𝑦 𝐿 = (1 − 𝛽) ∙ 𝐹. Luego el balance de masa de una especie “i”
se reduce a:
𝑧𝑖 = (1 − 𝛽) ∙ 𝑥𝑖 + 𝛽 ∙ 𝑦𝑖
Donde zi es la fracción molar global de la especie “i” en F, xi es la fracción molar en
la fase líquida e yi es la fracción molar en la fase vapor.
También se define a la relación de equilibrio Ki como:
𝐾𝑖 =𝑦𝑖𝑥𝑖
70
Proyecto Integrador Scortechini
Entonces aplicando la definición de Ki al balance de masa resulta:
𝑦𝑖 =𝑧𝑖 ∙ 𝐾𝑖
1 + 𝛽 ∙ (𝐾𝑖 − 1)
𝑥𝑖 =𝑧𝑖
1 + 𝛽 ∙ (𝐾𝑖 − 1)
Como en un sistema ∑𝑥𝑖 = ∑𝑦𝑖 = 1, se obtienen dos funciones:
𝐹𝑦 =∑𝑧𝑖 ∙ 𝐾𝑖
1 + 𝛽 ∙ (𝐾𝑖 − 1)− 1 = 0
𝑁
𝑖=1
𝐹𝑥 =∑𝑧𝑖
1 + 𝛽 ∙ (𝐾𝑖 − 1)
𝑁
𝑖=1
− 1 = 0
Por conveniencia se define:
𝐹 = 𝐹𝑦 − 𝐹𝑥 =∑𝑧𝑖 ∙ (𝐾𝑖 − 1)
1 + 𝛽 ∙ (𝐾𝑖 − 1)= 0
𝑁
𝑖=1
La conveniencia de esta función es que su derivada es siempre negativa y por lo
tanto F es monótona decreciente.
𝑑𝐹
𝑑𝛽= −∑
𝑧𝑖 ∙ (𝐾𝑖 − 1)2
[1 + 𝛽 ∙ (𝐾𝑖 − 1)]2
𝑁
𝑖=1
Esto permite aplicar el método de Newton para encontrar el valor de y garantizar
su convergencia.
𝐹 + (𝑑𝐹
𝑑𝛽) ∙ (𝛽𝑗 − 𝛽𝑗−1) = 0 ↔ 𝛽𝑗 = 𝛽𝑗−1 −
𝐹
(𝑑𝐹𝑑𝛽) (𝑁𝑒𝑤𝑡𝑜𝑛)
Donde el subíndice j de representa el número de iteración.
Para iniciar el cálculo se obtiene una estimación inicial de a partir de la relación:
𝛽 − 1
0 − 1=
𝑇 − 𝑇𝑟𝑜𝑐í𝑜𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 − 𝑇𝑟𝑜𝑐í𝑜
71
Proyecto Integrador Scortechini
Las estimaciones iniciales de {i} y {�̂�𝑖} surgen de:
𝛾𝑖 − 𝛾𝑖,𝑟𝑜𝑐í𝑜𝛾𝑖,𝑏𝑢𝑟𝑏𝑢𝑗𝑎 − 𝛾𝑖,𝑟𝑜𝑐í𝑜
=�̂�𝑖 − �̂�𝑖,𝑟𝑜𝑐í𝑜
�̂�𝑖,𝑏𝑢𝑟𝑏𝑢𝑗𝑎 − �̂�𝑖,𝑟𝑜𝑐í𝑜=
𝑇 − 𝑇𝑟𝑜𝑐í𝑜𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 − 𝑇𝑟𝑜𝑐í𝑜
Los valores de los coeficientes de actividad y de fugacidad para el rocío y la burbuja
se obtuvieron durante el proceso de cálculo de las respectivas temperaturas.
Así, con estos valores iniciales se pueden obtener los Ki según:
𝐾𝑖 =𝑦𝑖𝑥𝑖=𝛾𝑖 ∙ 𝑃𝑖
𝑠𝑎𝑡
𝑃 ∙ Φ𝑖
Entonces se pueden evaluar las funciones F y dF/d, se aplica el método de Newton
hasta que se encuentra un valor final de . Con éste se vuelven a estimar xi e yi, y se
evalúan de nuevo {i} y {�̂�𝑖}.
El procedimiento se repite hasta obtener valores constantes de , xi e yi con los
cuales se pueden calcular los caudales de líquido, de vapor y queda determinada la
composición de cada fase (Scenna, 1999).
La función calcularPropiedades2 sirve para calcular las propiedades termodinámicas
intensivas de la mezcla: entalpía, entropía, energía libre de Gibbs, energía interna,
volumen y energía de Helmholtz molares o específicas dependiendo de si el usuario
decidió trabajar con composiciones molares o en masa.
Se ha creado un clase particular para cada modelo termodinámico desarrollado en
éste capítulo: mezcla de gases ideales, solución ideal, Virial; Ecuaciones cúbicas de
estado que incluye Redlich-Kwong, Soave-Redlich-Kwong y Peng-Robinson;
Margules, Van Laar y Wilson. En cada caso las propiedades y parámetros se han
calculado programando directamente las respectivas fórmulas que se presentaron en
este capítulo.
Cada propiedad se plantea como la suma de dos términos: un término ideal y otro
corrector. Si el sistema se encuentra en esta líquido el término ideal se refiere a una
solución ideal; mientras que si es gaseoso el término ideal alude a una mezcla de
gases ideales. El término corrector cuando el sistema es líquido son las propiedades
en exceso; pero si es gaseoso entonces se corresponde con las propiedades
residuales. En función del estado de agregación del sistema, el programa
72
Proyecto Integrador Scortechini
diagnostica automáticamente que tipo de propiedades deben calcularse y crea un
objeto de la clase correspondiente. Una vez que dispone de los resultados, suma los
términos ideal y corrector para obtener la propiedad real del sistema.
Los primeros pasos
Un defecto observado en los simuladores comerciales es que los submenús que
sirven para hacer la configuración del sistema están dispersos en distintos menús
que se encuentran separados, y sus nombres no permiten inferir fácilmente su
función. Por ejemplo CHEMCAD posee un menú llamado “ThermoPhysical” que
permite seleccionar los paquetes de funciones termodinámicas, éste se encuentra en
la sexta posición después de “File”, “Edit”, “View”, “Format”, “Run Simulation” y antes
que el menú “Specifications” donde se eligen el sistema de unidades, tipo de
caudales, compuestos que intervienen en el proceso, etc. El menú “Specifications”
debería preceder a “Thermophysical” y a “Run Simulation”. En el caso de HYSYS,
ofrece muy pocos menús en la barra, sólo son tres: “File”, “Tools” y “Help”. De modo
que la mayoría de los submenús están en “Tools”, quedando éste saturado con
muchos submenús. A su vez cada submenú ofrece una cantidad excesiva de
posibilidades de configuración distribuidas en múltiples pestañas y columnas, que a
su vez abren otras ventanas con respectivo su arsenal de pestañas y más columnas.
Esto hace de la configuración un proceso largo y tedioso para el usuario
abrumándolo con demasiadas opciones (Aspen Technology Inc, 2003). Algo similar
ocurre con UNISIM (HoneyWell, 2010).
73
Proyecto Integrador Scortechini
Figura 9. Pantalla de Configuración de HYSYS.
Figura 10. Otra pantalla de Configuración de HYSYS.
74
Proyecto Integrador Scortechini
Figura 11. Pantalla de configuración de UNISIM.
Figura 12. Pantalla de selección de compuestos de UNISIM.
Una de las características del programa desarrollado es que todos los elementos
necesarios para operarlo se presentan en un orden lógico y son fáciles de utilizar.
Así, el primer menú se llama Configuración y sirve para establecer las condiciones
generales del proceso (configuración general, del sistema de unidades, de la lista de
compuestos, de los modelos termodinámicos o del tipo de caudales).
75
Proyecto Integrador Scortechini
Figura 13. Menú de configuración general del simulador.
El submenú “General” permite configurar todo el sistema (los demás submenús
permiten hacer configuraciones de ítems puntuales). Cuando se selecciona se
produce un evento de menú (esto ocurre siempre que se selecciona un menú o
submenú). Cuando se definió cada submenú en el módulo “menus”, también se le
enlazó el evento de menú y el método al que debe responder en caso de que se
produzca dicho evento. El método enlazado al submenú “General” se llama
“onConfGral” y su definición se encuentra en la biblioteca “metodos”.
El método “onConfGral” crea un objeto de la clase “DialogoConfGral” (definido en el
módulo “dialogos”) y le envía como parámetros el objeto de la clase “Proyecto” que
representa al proceso y otro objeto de la clase “BaseDeDatos”.
La clase “DialogoConfGral” hereda de dos superclases: wx.Frame que permite la
creación de ventanas, y “Componentes”, desarrollada en este proyecto, que contiene
definiciones de componentes visuales tales como: texto estático, control de texto,
botones, listas desplegables, etc.; así como funciones que automatizan su creación
en masa para aumentar la eficiencia del proceso y ahorrar código. Tiene un método
__init__ que se encarga de crear la ventana de diálogo que ofrece al usuario todas
las opciones de configuración y que se muestra a continuación:
76
Proyecto Integrador Scortechini
Figura 14. Diálogo de configuración general.
Para ello crea una ventana con barras de desplazamiento que contendrá a todos los
paneles, después llama a las funciones que hereda de la clase “Componentes” para
la creación automática de un panel por cada ítem a configurar, textos estáticos que
indican el ítem que se configura en cada panel, cajas de botones de radio para
seleccionar el sistema de unidades, modelos de gases y de líquidos; un cuadro de
lista para seleccionar los compuestos que forman parte del proceso y listas
desplegables con opciones de unidades para propiedades particulares.
Después tiene un método que permite agregar los componentes creados a unos
algoritmos llamados “sizers” (dimensionadores) que se encargan de hacer la
distribución física (Layout) de esos componentes en la pantalla para asegurarse que
quepan; luego asigna los dimensionadores a los correspondientes paneles, y un
tercer método agrega los paneles a la ventana principal del diálogo. Finalmente
llama al método “cargar” que intenta cargar información a partir del proceso, si es
que ésta existe (sino no hace nada).
El método “OnRadio” se encarga de hacer que, cuando el usuario seleccione el
Sistema Internacional o el Sistema Inglés como sistema de unidades, se seleccionen
77
Proyecto Integrador Scortechini
automáticamente las unidades correspondientes en las listas desplegables de las
respectivas propiedades.
El método “OnRecuperar” responde al evento de presión del botón “Aceptar” y se
encarga de revisar todos los controles que se muestran en el diálogo para recuperar
las opciones seleccionadas y se las asigna al atributo correspondiente del objeto
“Proyecto” que representa al proceso. Luego llama a la función “revisarCpL” que
verifica que los coeficientes para calcular la capacidad calorífica líquida de los
compuestos seleccionados estén en la base de datos, si es así entonces no hace
nada, en caso contrario crea un objeto de la clase “CpLDialog” que abre otra
ventana de diálogo y le muestra al usuario una tabla componentes-coeficientes,
invitándolo a ingresar la información faltante. Después llama al método
“revisarActividad” que hace algo similar pero para los coeficientes de la ecuación de
actividad, si el modelo de líquidos es la solución ideal esta función no hace nada.
Cabe aclarar que el usuario debe completar obligatoriamente todas las celdas de las
tablas mostradas por los dos diálogos anteriores, pues estos datos son
indispensables para los cálculos posteriores. Si el usuario omite algún dato el
sistema le muestra un mensaje de error indicándole que debe completar todos los
campos. También estos diálogos le muestran al usuario del programa un mensaje
ofreciéndole incorporar los datos ingresados de forma permanente a la base de
datos. Si el usuario acepta los datos se escriben en los respectivos archivos Excel,
de los contrario sus valores se utilizan para los cálculos del proceso actual pero no
estarán disponibles para otros procesos diferentes. Finalmente, llama al método
“onCerrar” que cierra la ventana y destruye a su objeto asociado, pero el objeto tipo
Proyecto retiene toda la información recolectada.
Figura 15. Mensaje de error durante la configuración de Cp líquidos.
78
Proyecto Integrador Scortechini
Figura 16. Diálogo de configuración para Cp líquidos.
Figura 17. Parámetros de los modelos de actividad.
La función “cargar” hace el trabajo opuesto a “OnRecuperar”. Tiene una lista que
relaciona los atributos de proceso (sistema de unidades, lista de compuestos, etc.)
con los respectivos componentes visuales que muestran su contenido en pantalla.
Entonces revisa los atributos del proceso y, si tienen asignado algún valor,
selecciona las opciones correspondientes en las cajas de botones de radio, listas
desplegables, cuadro de lista, etc. que se muestran en pantalla. Esta función se
invoca automáticamente, a través del método __init__, cada vez que se abre la
ventana de diálogo después de haber creado todos los componentes visuales de la
misma.
El primer panel permite seleccionar el sistema de unidades a utilizar, las opciones
son: Sistema Internacional, Sistema Inglés y Sistema Personalizado. Si el usuario
selecciona cualquiera de los dos primeros, las unidades de todas las propiedades se
seleccionan automáticamente; de lo contrario el usuario debe seleccionar las
unidades para formar su propio sistema de unidades personalizado.
79
Proyecto Integrador Scortechini
El segundo panel permite seleccionar los compuestos que se utilizarán en el proceso
de una lista con 469 compuestos, la mayoría orgánicos. El tercer panel permite optar
por caudales másicos o molares. El cuarto le ofrece varios modelos para representar
gases entre los que están el gas ideal, la ecuación Virial y tres ecuaciones de estado
cúbicas. El quinto panel ofrece opciones para modelar líquidos (solución ideal,
ecuación de Margules, de Van Laar o de Wilson). Los restantes permiten configurar
unidades de propiedades particulares.
Cuando se ha completado la selección, se debe oprimir el botón “Aceptar” para
guardar la selección o “Cancelar” para salir sin recuperar ninguna selección.
Los restantes submenús del menú “Configuración” permiten hacer configuraciones
análogas a “General” pero sólo de los atributos sugeridos por sus nombres (Lista de
compuestos, caudales, etc.).
Luego se debe continuar con el menú “Archivo” que se encuentra inmediatamente a
continuación del menú “Configuración”. Si se desea crear un nuevo proceso se debe
seleccionar el submenú “Nuevo”.
Figura 18. Menú Archivo del simulador.
Este submenú tiene enlazado un evento de menú al que responde llamando a la
función “onNuevoProc” que crea un diálogo estándar de wxPython de ingreso de
80
Proyecto Integrador Scortechini
texto para preguntar el nombre que se le desea dar al nuevo proceso, recupera el
texto ingresado y se lo asigna al atributo Nombre del objeto “Proyecto”. Luego llama
al método “onCrearCarpeta” que se encarga de crear una nueva carpeta con el
nombre del proceso que será utilizada para almacenar todos los archivos
relacionados con el proyecto.
Figura 19. Diálogo para nombrar el proyecto.
Si se desea modificar un proceso que ya existe, entonces se debe seleccionar el
submenú “Abrir”. Éste responde al evento de menú llamando al método “onAbrir” que
muestra un diálogo estándar de wxPython para la apertura de archivos. Se debe
buscar la carpeta donde esté guardado el archivo, seleccionar éste último y
entonces el programa abre el archivo y carga toda la información disponible.
Figura 20. Diálogo de apertura de proyectos.
81
Proyecto Integrador Scortechini
Además el método “Abrir” invoca a otro llamado “generarFlowsheet” que se encarga
de reconstruir el diagrama de flujo del proceso. Para eso revisa el diccionario
“Equipos” del objeto clase “Proyecto” clave por clave (corriente, nodo divisor,
mezclador, etc.), si el diccionario no está vacío (o sea, si hay equipos de ese tipo),
entonces crea un botón imagen con el ícono que representa a esa clase de equipo y
los enlaza con el objeto correspondiente que contiene la información de ese equipo.
Los submenús “Guardar” y “Guardar como” sirven para guardar los cambios en un
proceso existente y para guardar un proyecto recién creado, respectivamente.
“Guardar como” tiene asociado un método que abre un diálogo muy parecido a aquel
para abrir un archivo, pero éste sirve para guardar.
El submenú “Imprimir” se pensó con el fin de imprimir el contenido de la pantalla de
la computadora, pero no se realizó la programación para implementar esa función
primero por no considerarse prioritaria y, al final, por falta de tiempo.
El submenú “Cerrar” está enlazado a un método llamado “OnSalir” que cierra la
ventana del simulador y destruye todos los objetos creados.
Una vez completados estos primeros pasos preliminares, el usuario está en
condiciones de comenzar a representar el diagrama de flujo del proceso, creando los
equipos que forman parte del mismo e ingresando la información disponible acerca
de ellos.
Para construir el diagrama de flujo de proceso, debemos crear equipos y agregarlos
al paño de diseño en la ventana principal. Los recursos necesarios para eso se
encuentran en el menú “Insertar”. Éste contiene submenús que nos permiten crear
corrientes de proceso, nodos divisores, mezcladores, etc.
Cuando se selecciona cualquiera de estos submenús, o la herramienta equivalente
de la barra de herramientas, se genera un evento de menú y se llama al método
“onIcono”. Esta función se encarga de crear un botón que muestre, en vez de texto,
una imagen característica que se usa para representar a cada equipo (esa imagen
coincide con el ícono del submenú correspondiente) y de enlazarle una serie de
eventos.
82
Proyecto Integrador Scortechini
Figura 21. Menú Insertar del simulador.
Para eso, primero recupera el nombre del submenú seleccionado (o herramienta
seleccionada) para saber de qué tipo de equipo se trata y guarda este valor en una
variable llamada “tipo”. Luego se llama al método “preguntarNombre” que abre un
diálogo estándar de ingreso de texto para preguntarle al usuario el nombre que
desea darle a ese equipo, cuando el usuario hace clic sobre el botón “OK”, se
recupera el texto ingresado y se guarda en una variable llamada “nombre”.
Figura 22. Diálogo para nombrar un nuevo equipo.
83
Proyecto Integrador Scortechini
A continuación, se llama al método “buscarIcono”, al que se le pasa como argumento
el tipo de equipo, que tiene un diccionario usado para obtener el nombre del archivo
de imagen usado para representar a cada tipo de equipo, a partir de éste se crea
una imagen tipo mapa de bits y se la guarda en la variable llamada “bmp”. Entonces
se crea un botón de imagen, que pertenece al panel principal de la aplicación, y que
tiene como fondo la imagen creada anteriormente. Después se crea un objeto que
se encargará de acumular la información del equipo, si es una corriente se crea un
objeto de la clase Corriente, si es un intercambiador de calor se crea un objeto de la
clase Intercambiador, etc.; y se establecen referencias que relacionan al nombre del
equipo con el objeto que almacenará sus datos y con el botón sobre el paño que es
la parte del equipo que el usuario verá. El objeto que representa al equipo se agrega
al diccionario de “Equipos” del objeto clase “Proyecto” dentro del diccionario
correspondiente al tipo de equipo, por ejemplo:
Equipos = {‘Corriente’:{‘F01’:objetoF01, ‘F035’:objetoF035},
‘Tanque_Agitado_Continuo’:{‘T-001’:objetoT-001},
‘Flash’:{} (No hay ningún flash diccionario vacío)}
De forma análoga existe un diccionario “Equipos” que pertenece a la pantalla
principal, pero en vez de objetos clase equipo, guarda la referencia de los botones.
Equipos = {‘Corriente’:{‘F01’:botónF01, ‘F035’:botónF035},
‘Tanque_Agitado_Continuo’:{‘T-001’:botónT-001},
‘Flash’:{} (No hay ningún flash diccionario vacío)}
Uno de los eventos enlazados al botón es de particular interés, el evento menú
contextual. Este evento ocurre cuando el usuario hace clic con el botón derecho del
mouse, estando éste dentro de los límites del botón. A cada uno de los botones
creados se le enlaza este evento y, en respuesta al mismo, se ejecuta la función
“onShowPopup”. Esta función tiene la finalidad de enlazar un menú contextual
(también llamado emergente o Pop-up en inglés) al botón en cuestión. Para ello
tiene que determinar primero el nombre del equipo, su tipo y el botón que lo
representa, después llama al método “crearPopup” y le asigna al botón el menú
contextual. El método “crearPopup” es el encargado de fabricar el menú emergente,
para ello, crea un menú y tres submenús: “Orientación”, “Configurar” y “Borrar”.
84
Proyecto Integrador Scortechini
Figura 23. Menú emergente y sus distintas opciones.
El submenú “Orientación” ofrece alternativas de representación para cada equipo.
Para eso muestra un menú con distintas imágenes, cuando el usuario selecciona
una de ellas se produce un evento de menú que dispara el método
“onCambiarIcono” que recupera la opción seleccionada, prepara una imagen mapa
de bits con ese símbolo y luego cambia la imagen original mostrada por el botón por
la nueva selección.
Figura 24. Ejemplo de un pequeño diagrama de flujo.
85
Proyecto Integrador Scortechini
El submenú “Configurar” genera un evento que llama a la función “onDialogar”,
dependiendo del tipo de equipo, ésta crea una ventana de diálogo que permite
introducir y visualizar información relativa a ese equipo (cuando se trate cada equipo
en particular más adelante, se ampliará este punto).
Mientras que el submenú “Borrar” sirve para eliminar un equipo del proceso, como
consecuencia se destruye el botón que representa a ese equipo en la pantalla y
también el objeto que contiene toda su información.
Corriente
En este proyecto se supone que la corriente es una sola fase en la que no ocurren
reacciones químicas. El estado de agregación del sistema lo determina
automáticamente el método “evaluarFase” de la biblioteca termodinámica. Si la
corriente cae en la región de dos fases se muestra un mensaje de error y se le pide
al usuario que considere una separación flash. Para ello se creó el menú “Flash” que
se detallará más adelante. La corriente se representa mediante una flecha.
Figura 25. Representación de una corriente.
A continuación se muestra un análisis de los grados de libertad.
Tabla 5. Análisis de Corriente
Variables Ecuaciones
Tipo Cantidad Tipo Cantidad
Temperatura (T) 1 Suma de fracciones igual a uno 1
Presión (P) 1
Composiciones (zi o i) N
Caudal (F) 1
Total N+3 Total 1
Grados de Libertad N+2
86
Proyecto Integrador Scortechini
En la tabla anterior, y de aquí en adelante, N es el número de compuestos que
intervienen en el proceso. Si se conoce este número es posible saber el número
máximo de grados de libertad del sistema. Por ejemplo, si se proporcionan caudal,
temperatura, presión y N-1 composiciones la corriente quedará completamente
especificada y podrá resolverse (Himmelblau, 1997) (Henley-Seader, 2000).
Cuando se selecciona el submenú, o herramienta de, “Corriente”, el método que se
activa crea un objeto de la clase “Corriente”. Ésta contiene ocho métodos:
__init__: Este método recibe como parámetros un objeto clase
“BaseDeDatos” con el que crea un atributo “BD” que es la base de datos
propia de la corriente, y el objeto clase “Proyecto”. También crea los atributos
“Nombre”, “Caudal”, “T” y “P” que contienen la temperatura y la presión de la
corriente, “Composicion” que es un diccionario compuesto:fracción para
almacenar la composición molar o en masa del objeto. Los atributos “PM”,
“Composicion2”, “Tbub”, “Tdew”, “fase” almacenarán el peso molecular medio,
la composición alternativa en masa o molar, la temperatura de burbuja, la de
rocío, el estado de agregación respectivamente cuando se calculen
automáticamente esas propiedades. A los atributos anteriores se les asigna
un valor inicial simbólico, generado automáticamente, después de su
creación. Más adelante el usuario podrá visualizar esos valores, modificarlos
por símbolos propios o reemplazarlos por datos si así lo desea. Si el usuario
decidió trabajar con caudales molares en la configuración general del
proceso, entonces el diccionario “Composicion” hace referencia a la
composición molar y tanto el diccionario “Composicion2” como el término
“Composición alternativa” se refieren a la composición en masa. En cambio
cuando se trabaja con caudales másicos la “Composicion” alude a las
fracciones en masa y la “Composicion2” junto con la “Composición alternativa”
corresponden a las fracciones molares. Otros atributo como “H”, “V”, “S”, “G”,
“U”, y “A” sirven para guardar las propiedades termodinámicas entalpía,
volumen, entropía, energía libre de Gibbs, energía interna y energía de
Helmholtz molares o específicas de la mezcla dependiendo de con qué tipo
de caudales se esté trabajando. “ecs” e “inc” son listas donde se almacenarán
las ecuaciones e incógnitas propias de la corriente, “GL” que representa a los
grados de libertad, “unidades” que es un diccionario propiedad:unidad para
87
Proyecto Integrador Scortechini
relacionar el nombre de cada propiedad con su correspondiente unidad y “ref”
que es un diccionario símbolo:atributo que relaciona los símbolos de las
incógnitas con el correspondiente atributo de la corriente donde deberá
colocarse el resultado una vez que sea resuelta.
Actualizar: Este método sirve para llevar a cabo el proceso de actualización
de la corriente, intentando resolver las ecuaciones de la corriente. Para ello
llama a las funciones “Buscar_Incognitas”, “Formular_Ecuaciones” y
“CalcularGL”, si los grados de libertad son cero se llama al método “Resolver”
y luego a “Calcular_Props”.
Buscar_Incognitas: Esta función sirve para identificar las propiedades de la
corriente cuyo valor es desconocido. Esos valores los debe ingresar el usuario
a través del diálogo de configuración de corriente, este tema se tratará más
adelante con mayor detalle. La función “Buscar_Incognitas” primero reinicia la
lista de incógnitas y el diccionario de referencias (si tenían algo, se vacían),
luego considera el caudal, la temperatura, la presión y cada una de las
composiciones y revisa, uno por uno, sus valores con una estructura try-
except. El bloque dentro del “try” intenta convertir el valor de la propiedad en
un número real, si tiene éxito significa que el valor de esa propiedad es
conocido, no hace nada y pasa a la siguiente propiedad. Si no puede hacer lo
anterior, interpreta que el valor de esa propiedad es desconocido y se trata de
un símbolo algebraico, entonces ejecuta el bloque de sentencias después de
“except” que agrega el valor simbólico a la lista de incógnitas y al diccionario
“ref” agrega el par propiedad:valor simbólico.
Formular_Ecuaciones: Este método se encarga de generar automáticamente
las ecuaciones asociadas a la corriente, en realidad se trata sólo de una
∑ 𝑧𝑖 = 1𝑁𝑖=1 ↔ ∑ 𝑧𝑖 − 1 = 0
𝑁𝑖=1 , donde zi representa la fracción (molar o en
peso) de la especie “i” en la corriente. Para eso utiliza la función “sum” que
suma las fracciones de los compuestos, luego le resta uno a la suma y
guarda el resultado en una variable local llamada “ec”. Después utiliza una
estructura try-except para hacer una prueba. En el bloque “try” intenta
convertir “ec” en un número real, si esto tiene éxito pueden suceder dos
cosas: que la “ec” sea cero en cuyo caso significa que todas las
composiciones son conocidas y verifican la ecuación de restricción, entonces
no hace nada; o que la suma sea un número real distinto de cero, en cuyo
88
Proyecto Integrador Scortechini
caso todas las fracciones son conocidas (sino no podría convertir a “ec” en
real) pero su suma es distinta de la unidad, lo que significa que los datos son
incompatibles y entonces muestra un mensaje en pantalla notificando el
problema. Si no puede convertir a “ec” en número real, entonces significa que
debe haber al menos una composición desconocida y agrega “ec” a la lista de
ecuaciones “ecs”.
Calcular_GL: Sirve para calcular el número de grados de libertad de la
corriente que se obtiene como la diferencia entre la longitud (cantidad de
elementos) de la lista de incógnitas y la longitud de la lista de ecuaciones.
Resolver: Es un método que sirve para intentar resolver la ecuación de
restricción de la corriente. Para ello, primero verifica que todas las
composiciones excepto una sean conocidas. Si ese es el caso se tiene una
ecuación con una incógnita que puede resolverse. Entonces llama a la
función “solve” de la biblioteca “Sympy” de Python, le pasa como argumento
la ecuación de restricción y la instrucción que devuelva un diccionario
símbolo:valor como respuesta. Luego, le pasa al diccionario “ref” la clave del
diccionario respuesta, “ref” devuelve el nombre de la propiedad de la corriente
que está asociado con ese símbolo, le asigna el valor calculado a ese
atributo. Posteriormente disminuye en uno el número de grados de libertad,
elimina la composición calculada de la lista de incógnitas y también elimina la
ecuación pues ya fue resuelta. Si existe más de una composición
desconocida no hace nada.
Calcular_Props: Esta función sirve para calcular el peso molecular medio, la
composición alternativa, la temperatura de burbuja y de rocío, evaluar el
estado de agregación del sistema. También calcula las propiedades
termodinámicas entalpía, volumen, entropía, etc. molares o específicas. Para
eso, crea un objeto de la clase “SistemaTermodinamico”. Le envía como
parámetros la temperatura, la presión, la composición, la lista de compuestos,
la temperatura y presión de referencia, los modelos termodinámicos
seleccionados. Además le pasa una lista con los nombres de las propiedades
que desea obtener como respuesta. El funcionamiento del objeto
“SistemaTermodinamico” se explicó en el “Capítulo 4: Termodinámica”.
Cuando se completan esos cálculos los resultados se almacenan en las
variables apropiadas de la corriente.
89
Proyecto Integrador Scortechini
CalcularH1: Es una función que asiste a otra, externa a la clase “Corriente”,
encargada de realizar el balance de energía. Por razones de claridad se
pospone la explicación de este método hasta que se trate el balance de
energía en la sección dedicada a la clase “Mezclador”, pues allí se revela su
utilidad.
Cuando se selecciona la opción “Configurar” del menú pop-up el método
“onDialogar” crea un objeto de la clase “DialogoCorriente”. La clase
“DialogoCorriente” sirve para crear una ventana que le permita al usuario visualizar
la información conocida de esa corriente, si es que hay datos disponibles (o sea si
fueron ingresados previamente), modificarla, ingresar datos nuevos, realizar
cálculos, etc. El “DialogoCorriente” recibe como parámetros: el objeto “Proyecto”, el
objeto “Corriente” al que representa y la base de datos de propiedades. Luego el
dialogo se muestra en pantalla.
La pantalla de configuración de corriente está compuesta por once paneles, la
creación de estos junto con los componentes que contienen, está codificada en el
método __init__ de la clase “DialogoCorriente”. El primer panel contiene un texto
estático que nos informa el propósito del diálogo (configurar la corriente). El segundo
panel contiene dos textos, el primero identifica la propiedad de la corriente (el
nombre) y el segundo muestra su valor (por ejemplo, “F01”). Los paneles tercero,
cuarto y quinto, contienen un texto estático que identifica la propiedad de la
corriente, un control de texto que permite introducir o visualizar su valor y una lista
desplegable que muestra la unidad de esa propiedad, donde la propiedad es el
caudal, la temperatura y la presión respectivamente. El sexto panel tiene un texto
estático a los efectos de informar que se usa para configurar la composición y una
tabla que muestra la composición de la corriente y también permite modificarla; cada
fila representa un compuesto y en la única columna se muestra su fracción molar o
en peso de acuerdo con lo elegido en la configuración general del proceso. El
séptimo panel sirve para visualizar propiedades de la corriente como peso molecular
medio, composición en masa si se trabaja con caudales molares y viceversa, punto
de burbuja y de rocío, estado de agregación, entalpía, entropía, energía libre,
interna, de Helmholtz, volumen molares. Estos valores pueden visualizarse cuando
la corriente está completamente resuelta. Los paneles octavo, noveno y décimo
muestran textos estáticos para visualizar las incógnitas, las ecuaciones y los grados
90
Proyecto Integrador Scortechini
de libertad asociados a la corriente respectivamente. El último panel contiene tres
botones: “Aceptar”, “Actualizar” y “Cancelar”.
A continuación se muestra una imagen de la pantalla con algunos datos cargados:
Figura 26. Diálogo de configuración de corriente.
El botón “Cancelar” tiene asociado un método, llamado “onCancelar” que cierra la
ventana del diálogo y destruye todos sus componentes visuales (mas no los objetos
Proyecto, Corriente y BaseDeDatos) sin recuperar ninguna información, por lo tanto
no hay cambios en los valores de las propiedades.
91
Proyecto Integrador Scortechini
El botón “Aceptar” tiene enlazado el método “onAceptar” que llama a la función
“onRecuperar” , después llama al método “Actualizar” del objeto clase “Corriente” y
luego al método “onCancelar”. La función “onRecuperar” se encarga de guardar los
cambios en las propiedades antes de actualizar la corriente. Para eso, tiene
diccionarios que relacionan los componentes del diálogo (que se ven en pantalla)
con los atributos del objeto “Corriente” (que no se ven directamente en pantalla) y
funciones intrínsecas para recuperar los datos ingresados o las opciones
seleccionadas. Estos datos se recuperan como cadenas de caracteres, el
equivalente a una palabra; en el caso de las unidades de las propiedades, se
almacenan en ese formato en un diccionario, del objeto clase “Corriente”, tipo
propiedad:unidad. Pero los valores de la temperatura, la presión, la composición y el
caudal no deben almacenarse como cadenas de caracteres; si se trata de datos
(valores conocidos) se tienen que almacenar como números reales, en cambio si su
valor es desconocido deben guardarse como un símbolo algebraico. Para hacer eso
posible se utiliza una estructura llamada “excepción” que tiene el formato:
Try:
Bloque de sentencias
Except:
Bloque de sentencias alternativas
Las sentencias contenidas en el bloque “try” (intentar”) tratan de convertir los valores
de cada propiedad ingresados por el usuario en un número real, si tienen éxito
entonces quiere decir que se trata de valores conocidos y se guardan como números
reales. Pero si se produce una falla se genera la excepción y se ejecuta el bloque de
código contenido dentro del “except” (excepto). Esto implica que es imposible
convertir el valor ingresado por el usuario (por ejemplo, “x2”) a número real entonces
se interpreta que se trata de una incógnita, se crea un símbolo algebraico que lo
represente a partir de esa cadena de caracteres (“x2”) y se guarda el valor como un
símbolo. Aquí hay una diferencia importante con los simuladores comerciales,
algunos como UNISIM, no permiten ingresar caracteres que no sean numéricos en
las tablas de composición y si se dejan espacios en blanco, en vez de interpretarlos
como valores desconocidos, ajusta automáticamente a cero los valores respectivos;
otros interpretan los espacios en blanco como incógnitas, pero no permiten ingresar
92
Proyecto Integrador Scortechini
un símbolo que las represente, esta representación es interna y esos programas
asignan un código especial que identifican como incógnita pero que es ajeno al
usuario y éste no lo puede editar.
El botón “Actualizar” desencadena un evento de botón que llama al método
“OnActualizar”. Éste ejecuta la función “onRecuperar”, después invoca al método
“Actualizar” del objeto clase “Corriente” y activa el método “OnCargar” para recargar
la información de la corriente. La diferencia con respecto al botón “Aceptar” es que
“Actualizar” no cierra la ventana del diálogo. “OnCargar” se encarga de actualizar los
valores de caudal, temperatura y presión de la corriente y llama al método
“SetCompo”. La función “SetCompo” revisa el diccionario de composición del objeto
clase “Corriente”, relaciona el nombre de cada compuesto con el número de fila en la
tabla de composición que corresponde a esa especie, convierte el valor de la
fracción molar (o en peso) a una cadena de caracteres y la asigna a la celda
apropiada en la tabla. Después se invoca al método “SetEIGL” que se encarga de
recuperar la lista de ecuaciones, la de incógnitas y el número de grados de libertad
de la corriente, los convierte en cadenas de caracteres y luego le asigna esa cadena
al valor de los textos estáticos en los paneles que muestran esos datos.
Como resultado de los pasos anteriores la pantalla del diálogo se actualiza. A
continuación se muestra un ejemplo de la parte inferior de la pantalla:
Figura 27. Generación de incógnitas, ecuaciones y grados de libertad.
Si se agrega una composición más a la tabla, por ejemplo reemplazar wMetanol por
0.10, y se oprime el botón “Actualizar” sucede algo interesante:
93
Proyecto Integrador Scortechini
Figura 28. Resolución de ecuaciones de corriente.
La corriente no está completamente resuelta pues el número de grados de libertad
no es cero, sin embargo el dato agregado es suficiente para determinar
completamente la composición de la corriente. Los métodos de revisión y resolución
del objeto clase “Corriente” son capaces de detectar esta situación. Así, al actualizar,
estos nuevos resultados se muestran en pantalla y el sistema queda esperando
nueva información.
Además, cuando se conocen temperatura, presión y composición (molar o másica)
completa de la corriente es posible calcular el peso molecular medio, la composición
alternativa (másica o molar), punto de burbuja, de rocío y las propiedades
94
Proyecto Integrador Scortechini
termodinámicas intensivas de mezcla. Si ocurre este suceso se llama al método
“Calcular_Props” que se encarga de calcular las propiedades mencionadas
anteriormente.
Para eso se utiliza la biblioteca de funciones termodinámicas. Se crea un objeto
clase “SistemaTermodinamico” al que se le envía como argumentos: el objeto
corriente, su temperatura, su presión, la composición, el modelo de gases, el modelo
de líquidos, el tipo de caudales con que se trabaja. Luego este objeto se encarga de
realizar el cálculo de todas las propiedades y devuelve sus resultados, los que se
pueden visualizar en el panel “Propiedades” del dialogo de corriente. Los detalles de
los cálculos implicados se describieron en el capítulo de Termodinámica.
Nodo Divisor
En este proyecto se supone para el nodo divisor que Q = W = 0, y que en el proceso
no interviene el balance de energía.
Figura 29. Representación gráfica de un nodo divisor.
Está implícito el hecho de que las temperaturas, presiones y composiciones de las
corrientes de entrada y de salida son idénticas. La cuenta del número total de
variables, del número total de restricciones y de grados de libertad es la siguiente:
95
Proyecto Integrador Scortechini
Tabla 6. Análisis de Nodo Divisor
Variables Ecuaciones
Tipo Cantidad Tipo Cantidad
Temperatura (T) 3 Balances de Materia 1
Presión (P) 3 Igualdad de composición de F, P1 y P2 2(N-1)
Composición (zi o i) 3N TF=TP1=TP2 2
Caudal (F) 3 PF=PP2=PP3 2
Suma de fracciones igual a uno 3
Total 3N+9 Total 2N+6
Grados de Libertad N+3
Sólo se tiene en cuenta un balance de masa porque como
𝑧𝑖,𝐹 = 𝑧𝑖,𝑃1 = 𝑧𝑖,𝑃2 𝑝𝑎𝑟𝑎 1 ≤ 𝑖 ≤ 𝑁
Entonces los N balances de masa por componente:
𝐹 ∙ 𝑧𝑖,𝐹 = 𝑃1 ∙ 𝑧𝑖,𝑃1 + 𝑃2 ∙ 𝑧𝑖,𝑃2 𝑝𝑎𝑟𝑎 1 ≤ 𝑖 ≤ 𝑁
Se reducen al balance de masa global:
𝐹 = 𝑃1 + 𝑃2
Así, el número máximo de grados de libertad de un nodo divisor es N+3. Por
ejemplo, si se especifica el caudal de la alimentación, su composición, su
temperatura y presión, junto con uno de los caudales de salida se pueden resolver
todas las ecuaciones del nodo divisor (Himmelblau, 1997) (Sifuentes, 2000).
Cuando se selecciona el submenú, o herramienta de, “Nodo Divisor”, el método que
se activa crea un objeto de la clase “Nodo_Divisor”. Ésta contiene cinco métodos:
__init__: Este método recibe como atributos un objeto clase “BaseDeDatos”
con el que crea un atributo “BD” que es la base de datos del nodo divisor, y el
objeto clase “Proyecto”. También crea los atributos “Nombre”, “Entrada” que
contiene el nombre de la corriente de alimentación del nodo, “Salida1” y
“Salida2” que contienen los nombres de las corrientes de salida del nodo,
96
Proyecto Integrador Scortechini
“Corrientes” que es un diccionario tipo nombre:objeto corriente que relaciona
el nombre de las corrientes del nodo con los objetos clase “Corrientes” que las
representan, “Propiedades” es un diccionario que almacena el caudal, la
temperatura y la presión de las corrientes que interactúan con el nodo;
“Composicion” que es un diccionario cuyas claves son los nombres de los
compuestos que interviene en el proceso y cuyos valores son diccionarios que
relacionan el nombre de las corrientes del nodo con la fracción de cada
compuesto en esa corriente. “ecs”, “inc” y “GL” cumplen una función análoga
a los atributos homónimos de la clase “Corriente”, sólo que aquí las
ecuaciones, incógnitas y grados de libertad se refieren al nodo divisor. “ref” es
un diccionario que se usa para relacionar los símbolos de las incógnitas con la
corriente a la que están asociadas y la propiedad correspondiente.
Actualizar: Llama a los métodos “Buscar_Incognitas”, “Formular_Ecuaciones”
y “CalcularGL”. Cuando hay cero grados de libertad se invoca a la función
“Resolver”.
El método “Buscar_Incognitas” cumplen la misma función que el método
homónimo de la clase “Corriente” pero aquí las propiedades se refieren al
nodo divisor.
Formular_Ecuaciones: Esta función sirve para generar automáticamente la
ecuación del balance de masa que se reduce a:
𝐶𝑎𝑢𝑑𝑎𝑙 𝐸𝑛𝑡𝑟𝑎𝑑𝑎 = 𝐶𝑎𝑢𝑑𝑎𝑙 𝑆𝑎𝑙𝑖𝑑𝑎1 + 𝐶𝑎𝑢𝑑𝑎𝑙 𝑆𝑎𝑙𝑖𝑑𝑎2
porque las composiciones de las corrientes son idénticas, al igual que las
temperaturas y las presiones. Estas condiciones también generan una serie
de ecuaciones:
𝑧𝑖,𝐸𝑛𝑡𝑟𝑎𝑑𝑎 = 𝑧𝑖,𝑆𝑎𝑙𝑖𝑑𝑎1 𝑝𝑎𝑟𝑎 1 ≤ 𝑖 ≤ 𝑁 − 1
𝑧𝑖,𝑆𝑎𝑙𝑖𝑑𝑎1 = 𝑧𝑖,𝑆𝑎𝑙𝑖𝑑𝑎2 𝑝𝑎𝑟𝑎 1 ≤ 𝑖 ≤ 𝑁 − 1
𝑇𝐸𝑛𝑡𝑟𝑎𝑑𝑎 = 𝑇𝑆𝑎𝑙𝑖𝑑𝑎1
𝑇𝐸𝑛𝑡𝑟𝑎𝑑𝑎 = 𝑇𝑆𝑎𝑙𝑖𝑑𝑎2
𝑃𝐸𝑛𝑡𝑟𝑎𝑑𝑎 = 𝑃𝑆𝑎𝑙𝑖𝑑𝑎1
𝑃𝐸𝑛𝑡𝑟𝑎𝑑𝑎 = 𝑃𝑆𝑎𝑙𝑖𝑑𝑎2
Además se importan las ecuaciones de restricción de las corrientes del nodo y
se asegura que ninguna de las ecuaciones sea trivial, o sea que haya alguna
incógnita en ellas y que no sean identidades. Agrega las ecuaciones
generadas a la lista de ecuaciones del nodo divisor y, a partir de esta lista, se
97
Proyecto Integrador Scortechini
genera la cadena de caracteres a mostrar en el dialogo de configuración del
equipo.
Los métodos “Calcular_GL” y “Resolver”: Cumplen la misma función que los
métodos homónimos de la clase “Corriente” pero aquí los grados de libertad
se refieren al nodo divisor y cuando estos se anulan se intenta resolver las
ecuaciones del equipo.
Cuando se selecciona la opción “Configurar” del menú emergente asociado a un
botón de nodo divisor, el método “onDialogar” crea un objeto de la clase
“DialogoNodoDivisor” (que hereda de las superclases: wxFrame y Componentes), le
envía como parámetros al objeto clase “Proyecto”, al objeto clase “Nodo_Divisor”
que representa al equipo homónimo y la base de datos de propiedades, y lo muestra
en pantalla.
La clase “DialogoNodoDivisor” sirve para crear una ventana que le permita al usuario
visualizar la información conocida de ese nodo, si es que hay datos disponibles (o
sea si fueron ingresados previamente), modificarla, ingresar datos nuevos, realizar
cálculos, etc.
Figura 30. Diálogo de configuración de un nodo divisor.
98
Proyecto Integrador Scortechini
La pantalla está compuesta por once paneles, la creación de estos junto con los
componentes que contienen, está codificada en el método __init__ de la clase
“DialogoNodoDivisor”. El primer panel contiene un texto estático que nos informa el
propósito del diálogo (configurar el nodo). El segundo panel contiene dos textos, uno
que nos indica el atributo que se muestra (nombre) y el otro es el nombre del equipo
(D001). Los paneles tercero, cuarto y quinto sirven para seleccionar las corrientes
del nodo; el texto estático nos indica qué atributo estamos configurando y la lista
desplegable nos muestra un listado de corrientes del proceso que se pueden
seleccionar como entrada o salida. El sexto panel contiene una tabla que sirve para
visualizar, o modificar, las propiedades (caudal, temperatura y presión) de las
corrientes del equipo; las filas corresponden a las corrientes y las columnas a las
propiedades. El séptimo panel sirve para visualizar o modificar la composición de las
corrientes desde una tabla, nuevamente las filas corresponden a las corrientes y las
columnas a los compuestos de la lista de compuestos del proceso. Los paneles
octavo, noveno y décimo muestran las incógnitas, las ecuaciones y los grados de
libertad del nodo divisor. El último panel contiene los botones de comando “Aceptar”,
“Cargar”, “Actualizar” y “Cancelar”.
A modo de ejemplo, se generaron tres corrientes: “F01”, “F02” y “F03” de modo tal
que ninguna de ellas se pueda resolver por sí misma. Luego se creó un objeto
“Nodo_Divisor”. A continuación se muestra su pantalla de configuración con la
selección de las corrientes:
Figura 31. Selección de corrientes del nodo divisor.
99
Proyecto Integrador Scortechini
El paso siguiente es apretar el botón “Cargar” que genera un evento de botón y
llama al método “OnCargar”. Éste sirve para importar los correspondientes objetos
“Corriente” junto con sus datos. Para eso recupera la opción seleccionada de cada
lista desplegable y la asigna al atributo correspondiente (Entrada, Salida1 o Salida2)
del nodo divisor, luego recupera del diccionario de “Equipos” del proceso los
correspondientes objetos “Corriente” y los agrega a una lista de “Corrientes” del
nodo. Después, hace una revisión de las propiedades y la composición de cada
corriente, recupera sus valores, los convierte en cadenas de caracteres y los ubica
en la celda apropiada de la tabla correspondiente que se muestra en pantalla.
También almacena estos datos en los diccionarios de “Propiedades” y
“Composición” del objeto “Nodo_Divisor”. El resultado es el siguiente:
Figura 32. Carga de datos en diálogo de nodo divisor.
Cabe destacar como, después de haber seleccionado las corrientes del nodo, los
nombres de las filas en las tablas cambiaron para mostrar los nombres de esas
corrientes, ahora que son conocidas.
100
Proyecto Integrador Scortechini
Los botones “Aceptar”, “Actualizar” y “Cancelar”, junto con sus métodos asociados,
funcionan de manera análoga a sus homólogos de la clase “Corriente” pero operan
sobre el nodo divisor.
Veamos un ejemplo de lo que sucede si oprimimos el botón “Actualizar”:
Figura 33. Actualización de un nodo divisor.
101
Proyecto Integrador Scortechini
Si se introducen los siguientes datos: F3=595; T2=290K; P1=200000Pa y c2=0.06; y
luego se hace clic en “Actualizar” se obtiene el siguiente resultado:
Figura 34. Resolución completa de un nodo divisor.
De este modo, ha quedado resuelto el equipo y todas sus corrientes.
Mezclador
Por razones prácticas se ha decidido combinar los equipos “Mezclador de
Corrientes” y “Tanque Agitado Continuo” en uno solo llamado, a partir de ahora,
“Mezclador”. Se representa así:
Figura 35. Representación gráfica de un mezclador.
102
Proyecto Integrador Scortechini
Entonces el recuento de variables y ecuaciones para el mezclador es:
Tabla 7. Análisis de Mezclador
Variables Ecuaciones
Tipo Cantidad Tipo Cantidad
Temperatura (T) 3 Balances de Materia N
Presión (P) 3 Balances de Energía 1
Composición (zi o i) 3N Suma de fracciones igual a uno 3
Caudal (F) 3
Flujo de Calor (Q) 1
Flujo de Trabajo (Ws) 1
Total 3N+11 Total N+4
Grados de Libertad 2N+7
Entonces especificando el valor de 2N+7 variables se puede resolver completamente
el mezclador, las combinaciones pueden ser muy variadas (Himmelblau, 1997)
(Scenna, 1999).
Cuando se activa el submenú, o herramienta de, “Mezclador”, se crea un objeto de la
clase “Mezclador” que tiene seis métodos:
__init__: Este método recibe como atributos un objeto clase “BaseDeDatos”
con el que crea un atributo “BD” que es la base de datos del mezclador y el
objeto clase “Proyecto”. También crea los atributos “Nombre”, “Entrada1” y
“Entrada2” que contendrán los nombres de las corrientes de alimentación del
mezclador, “Salida” que contendrá el nombre de la corriente de salida del
mezclador cuando las seleccione el usuario; “Corrientes”, “Propiedades”,
“Composicion”, “ecs”, “inc”, “ref” y “GL” cumplen una función idéntica a los
atributos homónimos de la clase “Nodo_Divisor”, sólo que aquí se refieren al
mezclador.
Actualizar: Es un método que lleva a cabo el proceso de actualización del
objeto mezclador. Para ello llama a las funciones “Buscar_Incognitas”,
“Formular_Ecuaciones” y “CalcularGL”. Si el sistema tiene cero grados de
libertad, entonces llama al método “Resolver”.
103
Proyecto Integrador Scortechini
Buscar_Incognitas: Este método revisa los valores de las propiedades de las
corrientes del mezclador y de los atributos calor y trabajo de este último. Si
alguno de esos valores no es un número real, lo convierte en un símbolo
algebraico, lo agrega a la lista de incógnitas y crea una referencia
símbolo:atributo.
Formular_Ecuaciones: Esta función se encarga de plantear los balances de
masa por componente haciendo uso del Álgebra Lineal. Por ejemplo para un
sistema con tres componentes y tres corrientes: F1, F2 y F3 (salida):
[
𝑧11 𝑧12 𝑧13𝑧21 𝑧22 𝑧23𝑧31 𝑧32 𝑧33
] ∙ [𝐹1𝐹2−𝐹3
] = [𝐹1 ∙ 𝑧11 + 𝐹2 ∙ 𝑧12 − 𝐹3 ∙ 𝑧13𝐹1 ∙ 𝑧21 + 𝐹2 ∙ 𝑧22 − 𝐹3 ∙ 𝑧23𝐹1 ∙ 𝑧31 + 𝐹2 ∙ 𝑧32 − 𝐹3 ∙ 𝑧33
] = [000]
También plantea el balance de energía para un sistema en estado
estacionario.
[𝐹1 𝐹2 −𝐹3] ∙ [𝐻𝐹1 𝐻𝐹2 𝐻𝐹3] + 𝑄 +𝑊𝑠
= 𝐹1 ∙ 𝐻𝐹1 + 𝐹2 ∙ 𝐻𝐹2 − 𝐹3 ∙ 𝐻𝐹3 + 𝑄 +𝑊𝑠 = ∆𝐻 + 𝑄 +𝑊𝑠 = 0
Además importa las ecuaciones de restricción de las corrientes.
Para formular el balance de energía llama al método “CalcularH1” de cada
una de sus corrientes para intentar calcular su entalpía. El método
“CalcularH1” de una corriente calcula la entalpía de la misma a partir de la
siguiente fórmula:
𝐻1𝑗 =∑𝑧𝑖 ∙ [𝐻𝑖(𝑇0𝑖)0 +∫ 𝐶𝑝𝐿𝑖(𝑇) ∙ 𝑑𝑇
(1−𝛽)∙𝑇𝑗+𝛽∙𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 𝑗
𝑇0𝑖
]
𝑁
𝑖=1
+∑𝑧𝑖 ∙ [𝛽 ∙ ∆𝐻𝑣𝑖(𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 𝑗) + 𝛽 ∙ ∫ 𝐶𝑝𝐺𝑖(𝑇) ∙ 𝑑𝑇𝑇𝑗
𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 𝑗
]
𝑁
𝑖=1
Donde el subíndice “j” identifica a la corriente, zi es la fracción molar (o
másica, según con qué tipo de caudales trabaje el usuario) del componente “i”
en la corriente “j”, H0 vale 0 a T0i, esta última es la temperatura de referencia
para la especie “i”, es la fracción de vapor de la corriente, Tj es la
temperatura de la corriente “j”, CpLi y CpGi son las capacidades caloríficas
molares (o específicas) del compuesto “i” como líquido y como vapor
respectivamente y ΔHvi es el calor de vaporización de la especie “i”. La
función toma los siguientes valores (Smith, 1997):
𝛽 = {0, 𝑝𝑎𝑟𝑎 𝑙í𝑞𝑢𝑖𝑑𝑜𝑠1, 𝑝𝑎𝑟𝑎 𝑔𝑎𝑠𝑒𝑠
Y
104
Proyecto Integrador Scortechini
∆𝐻𝑣𝑖(𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 𝑗) = ∆𝐻𝑣𝑖(𝑇0𝑖) ∙ (𝑇𝑐𝑖 − 𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 𝑗
𝑇𝑐𝑖 − 𝑇0𝑖)0.38
(𝐹ó𝑟𝑚𝑢𝑙𝑎 𝑑𝑒 𝑊𝑎𝑡𝑠𝑜𝑛)
Si están disponibles todos los valores de las variables necesarias para
evaluar las fórmulas anteriores, entonces “CalcularH1” devuelve un número
como resultado. En caso contrario devuelve un símbolo algebraico del tipo
HNombre de la corriente.
Luego examina los valores de Q y Ws para estudiar si son datos conocidos o
expresiones simbólicas. Si cualquiera de las propiedades anteriores es un
dato aparecerá en el balance de energía como un número, sino aparecerá
como un símbolo. Luego se intenta convertir la ecuación de balance de
energía en número real, si tiene éxito verifica que sea igual a cero entonces
no hace nada; pero si resulta distinto de cero significa que el balance es
inconsistente y se muestra un mensaje de error. En caso contrario significa
que existen incógnitas, entonces verifica que sea sólo una e intenta resolverla
o agrega la ecuación a la lista de ecuaciones a la espera de más información.
Cuando se tiene una incógnita el balance de energía puede resolverse. Si la
incógnita es Q o Ws entonces asigna el resultado obtenido a esos atributos
del mezclador. Sino, se trata de la temperatura de una corriente, despeja el
valor de “H1j” y estudia su signo. Si éste es negativo la corriente se encuentra
en estado líquido y ajusta a 0, sino se trata de un gas y vale 1. Después
calcula la temperatura de burbuja de esa corriente, vuelve a plantear la
ecuación de “H1j” (sólo que ahora la única incógnita es la temperatura “Tj”), la
resuelve y guarda el resultado en el atributo “T” de la corriente
correspondiente. Finalmente elimina la ecuación y la incógnita resuelta de las
respectivas listas y disminuye en uno el número de grados de libertad.
CalcularGL: Igual que en los equipos anteriores.
Resolver: Igual que en los equipos anteriores.
Cuando se selecciona la opción “Configurar” del menú emergente asociado a un
botón de mezclador, el método “onDialogar” crea un objeto de la clase
“DialogoMezclador” (que hereda de las superclases: wxFrame y Componentes), le
envía como parámetros al objeto clase “Proyecto”, al objeto clase “Mezclador” que
representa al equipo homónimo y la base de datos de propiedades, y lo muestra en
pantalla.
105
Proyecto Integrador Scortechini
La clase “DialogoMezclador” sirve para crear una ventana que le permita al usuario
visualizar la información conocida de ese mezclador, si es que hay datos disponibles
(o sea si fueron ingresados previamente), modificarla, ingresar datos nuevos, realizar
cálculos, etc.
Figura 36. Diálogo de configuración de un mezclador.
La pantalla está compuesta por trece paneles, la creación de éstos junto con los
componentes que contienen, está codificada en el método __init__ de la clase
“DialogoMezclador”. El primer panel contiene un texto estático que nos informa el
propósito del diálogo (configurar el equipo). El segundo panel contiene dos textos,
uno que nos indica el atributo que se muestra (nombre) y el otro es el nombre del
equipo (M001). Los paneles tercero, cuarto y quinto sirven para seleccionar las
106
Proyecto Integrador Scortechini
corrientes del mezclador; el texto estático nos indica qué atributo estamos
configurando y la lista desplegable nos muestra una lista de corrientes del proceso
que se pueden seleccionar como entrada o salida. Los paneles sexto y séptimo
sirven para ingresar el flujo de calor y la potencia (flujo de trabajo) en el eje junto con
sus unidades. El octavo panel contiene una tabla que sirve para visualizar o
modificar las propiedades (caudal, temperatura y presión) de las corrientes del
equipo; las filas de la tabla corresponden a las corrientes y las columnas a las
propiedades. El noveno panel sirve para visualizar o modificar la composición de las
corrientes desde una tabla, nuevamente las filas corresponden a las corrientes y las
columnas a los compuestos de la lista de compuestos del proceso. Los paneles
décimo, décimo primero y décimo segundo muestran las incógnitas, las ecuaciones y
los grados de libertad del mezclador. El último panel contiene los botones de
comando “Aceptar”, “Cargar”, “Actualizar” y “Cancelar”.
A modo de ejemplo, se generaron tres corrientes: “F01”, “F02” y “F03” de modo tal
que ninguna de ellas se pueda resolver por sí misma. Luego se creó un objeto
“Mezclador”. A continuación se muestra la parte superior de la pantalla con la
selección de las corrientes:
Figura 37. Selección de corrientes del mezclador.
El paso siguiente es apretar el botón “Cargar” que genera un evento de botón y
llama al método “OnCargar”. Éste sirve para importar los correspondientes objetos
“Corriente” junto con sus datos. Para eso recupera la opción seleccionada de cada
lista desplegable y la asigna al atributo correspondiente (Entrada1, Entrada2 o
Salida) del mezclador, luego recupera del diccionario de “Equipos” del proceso los
correspondientes objetos “Corriente” y los agrega a una lista de “Corrientes” del
mezclador. Después, hace una revisión de las propiedades y la composición de cada
corriente, recupera sus valores, los convierte en cadenas de caracteres y los ubica
en la celda apropiada de la tabla correspondiente que se muestra en pantalla.
107
Proyecto Integrador Scortechini
También almacena estos datos en los diccionarios de “Propiedades” y
“Composición” del objeto “Mezclador”. El resultado es el siguiente:
Figura 38. Carga de datos en diálogo de mezclador.
Si a continuación se oprime el botón “Cancelar” se invoca al método “OnCancelar”
que cierra la ventana y destruye al objeto “DialogoMezclador”, pero no al objeto
“Mezclador”, además la selección de las corrientes persiste.
En cambio cuando se hace clic sobre el botón “Aceptar” o “Actualizar” se llama a la
función “Actualizar”, del mezclador, que identifica las incógnitas, formula las
ecuaciones y calcula el número de grados de libertad. Si se tienen cero grados de
libertad, llama al método “Resolver” para calcular todas las incógnitas del equipo.
108
Proyecto Integrador Scortechini
Después se asignan los valores hallados a los respectivos atributos de las corrientes
y del mezclador.
Finalmente se invoca al método “OnCargar” para recargar la información y que el
usuario pueda visualizarla en pantalla.
La diferencia es que “Aceptar” cierra el diálogo después de completar los cálculos,
mientras que “Actualizar” lo deja abierto para poder visualizar los resultados.
Veamos un ejemplo:
Figura 39. Actualización y resolución de un mezclador.
109
Proyecto Integrador Scortechini
Flash
A un separador flash ingresa una corriente que se separa en otras dos que están en
equilibrio, en este proyecto se supone que W=0 pero no Q. Se puede representar de
la siguiente manera:
Figura 40. Representación gráfica de un flash.
Los grados de libertad del flash se calculan así:
Tabla 8. Análisis de Flash
Variables Ecuaciones
Tipo Cantidad Tipo Cantidad
Temperatura (TA, TL, TV) 3 Balances de Materia N
Presión (PA, PL, PV) 3 Balances de Energía 1
Composición (zi o i) 3N Relaciones de equilibrio N
Caudal (F) 3 TL=TV (Equilibrio de fases) 1
Flujo de Calor (Q) 1 PL=PV (Equilibrio de fases) 1
Suma de fracciones igual a uno 3
Total 3N+10 Total 2N+6
Grados de Libertad N+4
Así, si se especifican los valores de N+4 variables independientes se puede resolver
el flash.
Por razones de simplicidad este equipo se modeló de forma modular secuencial, es
decir para poder resolver los cálculos se debe especificar completamente la corriente
de entrada, es decir proveer N-1 composiciones, temperatura, presión y caudal de la
misma; definir el flujo de calor (en caso de operación adiabática, ingresar 0), y la
110
Proyecto Integrador Scortechini
temperatura o la presión de equilibrio de una corriente de salida. Luego el programa
calcula las salidas del flash.
Cuando se activa el submenú, o herramienta de, “Flash”, el método que asociado
crea un objeto de la clase “Flash” que tiene seis métodos:
__init__: Este método recibe como parámetros un objeto “BaseDeDatos” y
otro tipo “Proyecto”. Luego crea los atributos “Nombre”, “Alimentación”,
“Vapor”, “Líquido”, “beta” (fracción de vapor) y “Calor”. Los campos
“Corrientes”, “ecs”, “inc”, “ref” y “GL” cumplen una función idéntica a los
atributos homónimos de la clase “Nodo_Divisor”, pero aquí se refieren al flash.
Actualizar: Es un método que lleva a cabo el proceso de actualización del
equipo flash. Lo hace llamando a las funciones “Buscar_Incognitas”,
“Formular_Ecuaciones” y “CalcularGL”. Cuando hay cero grados de libertad,
entonces llama al método “Resolver”.
Buscar_Incognitas: Este método revisa los valores de las propiedades de las
corrientes del flash y de los atributos “beta” y “Calor” de este último. Si alguno
de esos valores no es un número real, lo convierte en un símbolo algebraico,
lo agrega a la lista de incógnitas y crea una referencia símbolo:atributo.
Formular_Ecuaciones: Esta función se encarga de plantear las ecuaciones
asociadas con el flash.
Los balances de masa por componente se formulan haciendo uso del Álgebra
Lineal. Por ejemplo para un flash con dos componentes y tres corrientes: F, L
y V:
[𝑧1𝐴 𝑧1𝐿 𝑧1𝑉𝑧2𝐴 𝑧2𝐿 𝑧2𝑉
] ∙ [𝐹𝐿𝑉] = [
𝑧1𝐹 ∙ 𝐹 − 𝑧1𝐿 ∙ 𝐿 − 𝑧1𝑉 ∙ 𝑉𝑧2𝐹 ∙ 𝐹 − 𝑧2𝐿 ∙ 𝐿 − 𝑧2𝑉 ∙ 𝑉
] = [00]
También se plantea un balance de energía:
𝐹 ∙ 𝐻𝐹 − 𝐿 ∙ 𝐻𝐿 − 𝑉 ∙ 𝐻𝑉 + 𝑄 = 0
Además existen relaciones de equilibrio de fases para los componentes:
𝑦1 − 𝐾1 ∙ 𝑥1 = 0
𝑦2 − 𝐾2 ∙ 𝑥2 = 0
111
Proyecto Integrador Scortechini
donde 𝐾𝑖 =𝛾𝑖∙𝑃𝑖
𝑠𝑎𝑡
𝑃∙Φ𝑖 𝑝𝑎𝑟𝑎 𝑖 = 1,2 y estos valores son calculados internamente
por el programa haciendo uso de las funciones de la biblioteca
termodinámica.
Más relaciones de igualdad de temperatura y presión debido al equilibrio de
fases:
𝑇𝐿 = 𝑇𝑉
𝑃𝐿 = 𝑃𝑉
Finalmente las ecuaciones de restricción de cada corriente.
∑𝑧𝑖𝑗 = 1 𝑝𝑎𝑟𝑎 1 ≤ 𝑗 ≤ 3
𝑁
𝑖=1
El subíndice “i” hace referencia a las especies químicas presentes en el
sistema (N) y el subíndice “j” indica la corriente a la que se aplica la ecuación
(3 corrientes).
CalcularGL: Se encarga de calcular en número de grados de libertad en base
a la cantidad de incógnitas y de ecuaciones.
Resolver: Esta función implementa los cálculos flash descriptos al final del
apartado “La clase SistemaTermodinamico” de este capítulo, para calcular
todas las propiedades desconocidas.
Cuando se selecciona la opción “Configurar” del menú emergente asociado a un
botón de flash, el método “onDialogar” crea un objeto de la clase “DialogoFlash” (que
hereda de las superclases: wxFrame y Componentes), le envía como parámetros al
objeto clase “Proyecto”, al objeto clase “Flash” que representa al equipo homónimo y
la base de datos de propiedades, y lo muestra en pantalla.
La clase “DialogoFlash” sirve para crear una ventana que le permita al usuario
visualizar la información conocida de ese equipo, si es que hay datos disponibles (o
sea si fueron ingresados previamente), modificarla, ingresar datos nuevos, realizar
cálculos, etc.
La pantalla está compuesta por trece paneles, la creación de éstos junto con los
componentes que contienen, está codificada en el método __init__ de la clase
112
Proyecto Integrador Scortechini
“DialogoFlash”. El primer panel contiene un texto estático que nos informa el
propósito del diálogo (configurar el equipo). El segundo panel contiene dos textos,
uno que nos indica el atributo que se muestra (nombre) y el otro es el nombre del
equipo (FL001). Los paneles tercero, cuarto y quinto sirven para seleccionar las
corrientes del flash; el texto estático nos indica qué atributo estamos configurando y
la lista desplegable nos muestra una lista de corrientes del proceso que se pueden
seleccionar como entrada o salida. El sexto panel nos permite ingresar el flujo de
calor para el caso de que la alimentación se caliente antes de entrar en el separador,
sinó se debe ingresar 0 (operación adiabática). El séptimo mostrará la fracción de
vapor una vez que sea calculada. El octavo panel contiene una tabla que sirve para
visualizar o modificar las propiedades (caudal, temperatura y presión) de las
corrientes del equipo. El noveno panel sirve para visualizar o modificar la
composición de las corrientes desde una tabla. Los paneles décimo, décimo primero,
y décimo segundo muestran las incógnitas, las ecuaciones y los grados de libertad
del equipo. El último panel contiene los botones de comando “Aceptar”, “Cargar”,
“Actualizar” y “Cancelar”.
A modo de ejemplo, se generaron tres corrientes: “A”, “L” y “V”. Se completaron
todos los atributos de la alimentación “A”, luego se creó un objeto “Flash”. A
continuación se muestra su pantalla de configuración con la selección de las
corrientes:
Figura 41. Diálogo de configuración de flash.
Luego se debe apretar el botón “Cargar” que genera un evento de botón y llama al
método “OnCargar”. Éste sirve para importar los correspondientes objetos
113
Proyecto Integrador Scortechini
“Corriente” junto con sus datos. Para eso recupera la opción seleccionada de cada
lista desplegable y la asigna al atributo correspondiente (Alimentación, Líquido o
Vapor) del flash. Luego recupera del diccionario de “Equipos” del proceso los
correspondientes objetos “Corriente” y los agrega a una lista de “Corrientes” del
equipo. Después, hace una revisión de las propiedades y la composición de cada
corriente, recupera sus valores, los convierte en cadenas de caracteres y los ubica
en la tabla correspondiente que se muestra en pantalla. También almacena estos
datos en los diccionarios de “Propiedades” y “Composición” del objeto “Flash”.
Si a continuación se oprime el botón “Cancelar” se invoca al método “OnCancelar”
que cierra la ventana y destruye al objeto “DialogoFlash”, pero no al objeto “Flash”,
además la selección de las corrientes persiste.
En cambio cuando se hace clic sobre el botón “Aceptar” o “Actualizar” se llama a la
función “Actualizar”, del flash, que identifica las incógnitas, formula las ecuaciones y
calcula el número de grados de libertad. Si se tienen cero grados de libertad, llama al
método “Resolver” para calcular todas las incógnitas del equipo. Después se asignan
los valores hallados a los respectivos atributos de las corrientes y del flash.
Finalmente se invoca al método “OnCargar” para recargar la información y que el
usuario pueda visualizarla en pantalla.
La diferencia es que “Aceptar” cierra el diálogo después de completar los cálculos,
mientras que “Actualizar” lo deja abierto para poder visualizar los resultados.
A continuación se muestra una pantalla del simulador y otras de UNISIM donde se
resuelve un problema y se presentan los resultados. Puede observarse que los
resultados concuerdan.
114
Proyecto Integrador Scortechini
Figura 42. Actualización y resolución de flash.
Figura 43. Representación de un flash en UNISIM.
115
Proyecto Integrador Scortechini
Figura 44. Resultados de cálculo flash con UNISIM.
Intercambiador de Calor
Se representa el intercambiador de calor de la siguiente manera.
Figura 45. Representación gráfica de un intercambiador de calor.
En este proyecto se supone que W=0 para el intercambiador, pero no Q. Entonces el
análisis de grados de libertad es el mostrado en la siguiente tabla.
116
Proyecto Integrador Scortechini
Tabla9: Análisis de Intercambiador de Calor
Variables Ecuaciones
Tipo Cantidad Tipo Cantidad
Temperatura (T) 4 Balances de Materia 2
Presión (P) 4 Balance de Energía 1
Composición (zi o wi) 4N Igualdad de composición 2N-2
Caudal (F) 4 Suma de fracciones igual a uno 4
Flujo de Calor (Q) 1 Definición de Q 1
DTML 1 Definición de DTML 1
Eficiencia 1 Definición de E 1
A 1 Ley de Transferencia de calor 1
UD 1
Total 4N+17 Total 2N+9
Grados de Libertad 2N+8
De modo que si se dan los valores de 2N+8 variables independientes es posible
resolver completamente el intercambiador.
Cuando se selecciona el submenú, o herramienta de, “Intercambiador de Calor”, el
método que asociado crea un objeto de la clase “IntercambiadorDeCalor” que tiene
los métodos descriptos a continuación:
__init__: Este método recibe como parámetros un objeto “BaseDeDatos” y
otro tipo “Proyecto”. Luego crea los atributos “Nombre”, “Ac” (Alimentación
Caliente), “Af” (Alimentación Caliente), “Pc” (Producto Caliente), “Pf”
(Producto frío), “Configuración” inicialmente vacíos. También “U”, “Area”,
“DTML” y “Calor” inicialmente con valores simbólicos. Los campos
“Corrientes”, “Propiedades”, “Composición”, “ecs”, “inc”, “ref” y “GL” cumplen
una función idéntica a los atributos homónimos de la clase “Nodo_Divisor”,
pero aquí se refieren al intercambiador.
Actualizar: Es un método que lleva a cabo el proceso de actualización del
equipo. Para eso llama a los métodos “Buscar_Incognitas”,
“Formular_Ecuaciones” y “CalcularGL”. Cuando hay cero grados de libertad,
entonces llama al método “Resolver”.
Buscar_Incognitas: Este método revisa los valores de las propiedades de las
corrientes del intercambiador y de los atributos “U” y “Area” de este último. Si
alguno de esos valores no es un número real, lo convierte en un símbolo
117
Proyecto Integrador Scortechini
algebraico, lo agrega a la lista de incógnitas y crea una referencia
símbolo:atributo.
Formular_Ecuaciones: Esta función se encarga de plantear los balances de
masa de la siguiente manera:
𝐴𝑐 = 𝑃𝑐
𝐴𝑓 = 𝑃𝑓
También se plantea un balance de energía:
𝐴𝑐 ∙ 𝐻𝐴𝑐 + 𝐴𝑓 ∙ 𝐻𝐴𝑓 − 𝑃𝑐 ∙ 𝐻𝑃𝑐 − 𝑃𝑓 ∙ 𝐻𝑃𝑓 = 0
Además existen restricciones de igualdad de composición:
𝑧𝑖,𝐴𝑐 − 𝑧𝑖,𝑃𝑐 = 0 𝑝𝑎𝑟𝑎 1 ≤ 𝑖 ≤ 𝑁 − 1
𝑧𝑖,𝐴𝑓 − 𝑧𝑖,𝑃𝑓 = 0 𝑝𝑎𝑟𝑎 1 ≤ 𝑖 ≤ 𝑁 − 1
donde zi es la composición de la especie “i” en la corriente indicada.
También las ecuaciones de restricción de cada corriente.
Plantea una ecuación de definición de Q que relaciona el flujo de calor, que
ocurre dentro del equipo (subsistemas), con la variación de entalpía de uno de
los fluidos. Por ejemplo:
𝑄 = 𝐴𝑓 ∙ (𝐻𝑃𝑓 − 𝐻𝐴𝑓)
Otra ecuación es la que define a la diferencia de temperatura media
logarítmica:
∆𝑇𝑀𝐿 =∆𝑇2 − ∆𝑇1𝑙𝑛(∆𝑇2 ∆𝑇1⁄ )
=
{
(𝑇1𝐶 − 𝑇2𝑓) − (𝑇2𝑐 − 𝑇1𝑓)
𝑙𝑛[(𝑇1𝐶 − 𝑇2𝑓) (𝑇2𝑐 − 𝑇1𝑓)⁄ ], 𝑓𝑙𝑢𝑗𝑜 𝑐𝑜𝑛𝑡𝑟𝑎𝑐𝑜𝑟𝑟𝑖𝑒𝑛𝑡𝑒
(𝑇2𝐶 − 𝑇2𝑓) − (𝑇1𝑐 − 𝑇1𝑓)
𝑙𝑛[(𝑇2𝐶 − 𝑇2𝑓) (𝑇1𝑐 − 𝑇1𝑓)⁄ ], 𝑓𝑙𝑢𝑗𝑜 𝑝𝑎𝑟𝑎𝑙𝑒𝑙𝑜
118
Proyecto Integrador Scortechini
La ecuación de definición de eficiencia es:
휀 =
{
(𝑇2𝑓 − 𝑇1𝑓)
(𝑇1𝑐 − 𝑇1𝑓), 𝑠𝑖 𝐶𝑐 > 𝐶𝑓 𝑦 𝑐𝑜𝑛𝑡𝑟𝑎𝑐𝑜𝑟𝑟𝑖𝑒𝑛𝑡𝑒
(𝑇2𝑓 − 𝑇1𝑓)
(𝑇2𝑐 − 𝑇1𝑓), 𝑠𝑖 𝐶𝑐 > 𝐶𝑓 𝑦 𝑝𝑎𝑟𝑎𝑙𝑒𝑙𝑜
(𝑇1𝑐 − 𝑇2𝑐)
(𝑇1𝑐 − 𝑇2𝑓), 𝑠𝑖 𝐶𝑐 < 𝐶𝑓 𝑝𝑎𝑟𝑎 𝑎𝑚𝑏𝑜𝑠 𝑓𝑙𝑢𝑗𝑜𝑠
Donde Cc y Cf son las capacidades de flujo térmico de las corrientes.
𝐶𝑎𝑝𝑎𝑐𝑖𝑑𝑎𝑑 𝑑𝑒 𝑓𝑙𝑢𝑗𝑜 𝑡é𝑟𝑚𝑛𝑖𝑐𝑜 = 𝑐𝑎𝑢𝑑𝑎𝑙 ∙ 𝑐𝑎𝑝𝑎𝑐𝑖𝑑𝑎𝑑 𝑐𝑎𝑙𝑜𝑟í𝑓𝑖𝑐𝑎 𝑝𝑟𝑜𝑚𝑒𝑑𝑖𝑜
Además los subíndices “f” y “c” hacen referencia a las corrientes frías y
calientes. Mientras que “1” y “2” se refieren a entrada o alimentación y salida o
producto respectivamente (Kern, 1999).
Finalmente la ley de transferencia de calor es:
𝑄 = 𝑈 ∙ 𝐴 ∙ ∆𝑇𝑀𝐿
CalcularGL: Se encarga de calcular en número de grados de libertad en base
a la cantidad de incógnitas y de ecuaciones.
Resolver: Este método llama a la función “solve” de la librería “SymPy” a la
que le pasa la lista de ecuaciones a resolver y la orden de devolver un
diccionario símbolo:valor en caso de encontrar una solución. Si encuentra una
solución única asigna los valores hallados a las propiedades correspondientes
de las corrientes o del intercambiador, sino no hace nada.
Cuando el usuario selecciona la opción “Configurar” del menú emergente asociado a
un botón de intercambiador de calor, la función “onDialogar” crea un objeto de la
clase “DialogoIntercambiadorDeCalor”, le envía como parámetros al objeto clase
“Proyecto”, al objeto clase “IntercambiadorDeCalor” que representa al equipo
homónimo y la base de datos de propiedades, y lo muestra en pantalla.
La clase “DialogoIntercambiadorDeCalor” sirve para crear una ventana que le
permita al usuario visualizar la información conocida de ese equipo, si es que hay
datos disponibles (o sea si fueron ingresados previamente), modificarla, ingresar
datos nuevos, realizar cálculos, etc.
La pantalla está compuesta por dieciocho paneles, la creación de éstos junto con los
componentes que contienen, está codificada en el método __init__ de la clase
“DialogoIntercambiadorDeCalor”. El primer panel muestra el título del diálogo, el
119
Proyecto Integrador Scortechini
segundo el nombre del equipo. Los cuatro paneles siguientes sirven para
seleccionar las corrientes que interactúan con el intercambiador. El sexto panel
permite seleccionar el modo de operación (flujo paralelo o flujo contracorriente), el
séptimo permite ingresar o visualizar el coeficiente global de transferencia de calor,
el octavo está reservado para el área de intercambio de calor, el noveno para la
diferencia de temperatura media logarítmica y el décimo permite visualizar el calor
intercambiado por las corriente cuando sea calculado por el sistema. El décimo
primer panel muestra la eficiencia de intercambio calórico cuando pueda ser
calculado automáticamente. Los restantes muestran propiedades, composición,
incógnitas, ecuaciones, grados de libertad y botones de comando como en los
demás diálogos.
A continuación se muestra una pantalla típica de configuración con los datos de las
corrientes cargados.
Figura 46. Configuración de un intercambiador de calor.
120
Proyecto Integrador Scortechini
Cuando se hace clic en el botón “Actualizar”, se resuelven automáticamente los
caudales faltantes, la temperatura desconocida, la diferencia de temperatura media
logarítmica y la eficiencia.
Figura 47. Actualización de un intercambiador de calor.
Todavía queda un grado de libertad. Si se especifica que el área de intercambio
calórico es de 10m2 y se vuelve a actualizar, el equipo se resuelve completamente.
121
Proyecto Integrador Scortechini
Figura 48. Resolución completa de un intercambiador de calor.
Menús Auxiliares
El resto de los menús del simulador permiten acceder a funciones complementarias
que nos permiten realizar consultas a la base de datos, elegir las herramientas que
deseamos ver y obtener ayuda. A continuación se hace una breve descripción de
ellos.
El menú Herramientas
Este menú agrupa a los submenús: “Consultar Biblioteca”, “Agregar Compuesto”,
“Editar Compuesto”, “Balance de Masa”, “Balance de Energía” y “Documentar”.
122
Proyecto Integrador Scortechini
Figura 49. Menú Herramientas.
Cuando se selecciona el submenú “Consultar Biblioteca” se llama al método
“OnConsultarBiblioteca” del módulo “Metodos”. Esa función crea un dialogo que le
permite al usuario seleccionar compuestos presentes en la base de datos y luego
presenta una tabla que muestra las propiedades de esas especies que figuran en la
base de datos. Para ello construye un objetos de la case “DialogoConsultaBiblioteca”
que sirve para fabricar el diálogo y mostrarlo en pantalla.
La selección del submenú “Agregar Compuesto” abre un diálogo que permite
incorporar un nuevo compuesto a la base de datos.
En cambio el submenú “Editar Compuesto” le permite al usuario visualizar en
pantalla las propiedades de un compuesto químico y modificar sus valores.
Los restantes submenús de Herramientas no se programaron por falta de tiempo.
123
Proyecto Integrador Scortechini
Figura 50. Diálogo de Consulta a Biblioteca.
124
Proyecto Integrador Scortechini
Figura 51. Diálogo para agregar nuevo compuesto.
Figura 52. Diálogo para editar compuesto.
El Menú Ver
Los submenús que contiene son “Barra de Herramientas” y “Barra de Estado”.
Cuando se selecciona alguno de ellos el programa llama a una función que sirve
para cambiar el estado de visibilidad del elemento al que hacen alusión. Por defecto
la barra de herramientas y la de estado están visibles, pero si el usuario necesita
125
Proyecto Integrador Scortechini
más espacio en pantalla y desea ocultarlas entonces puede seleccionar estos
submenús. Si en el futuro desea hacerlas visibles nuevamente solo debe ingresar al
menú “Ver” y seleccionar la opción correspondiente.
Figura 53. Opciones del menú Ver.
El Menú Ayuda
Este menú posee dos submenús: “Acerca de los Autores” y “Manual de Usuario”.
Cuando se selecciona el primero de ellos el método “OnAcerca” crea un diálogo que
sirve para mostrar información, en este caso del autor de este proyecto, y lo
despliega en pantalla. “Manual de Usuario” llama a la función “OnManual” que le
ordena al sistema operativo que abra el archivo que contiene el manual de usuario
para proporcionar ayuda. Por razones de tiempo no se alcanzó a desarrollar un
manual de usuario, pero éste se reemplazó con un archivo similar al capítulo 5 de
este informe donde se explican los componentes del programa y a los Anexos que
contienen ejemplos de aplicación, con la esperanza de orientar al usuario del
simulador.
126
Proyecto Integrador Scortechini
Figura 54. El menú Ayuda.
Figura 55. Diálogo Acerca de los Autores.
127
Proyecto Integrador Scortechini
Bibliografía
Aspen Technology Inc. (2003). HYSYS Tutorial & Applications. Cambridge.
Geankoplis, C. J. (1998). Procesos de Transporte y Operaciones Unitarias (3°
Edición ed.). Mexico: CECSA.
Henley-Seader. (2000). Operaciones de Separación por Etapas en Ingeniería
Química. México D.F.: Editorial Reverté S.A.
Himmelblau, D. M. (1997). Principios Básicos y Cálculos en Ingeniería Química.
México D.F.: Prentice Hall.
HoneyWell. (2010). UNISIM Design. London.
Kern, D. Q. (1999). Procesos de Transferencia de Calor. México D. F.: CECSA.
Scenna, N. J. (1999). Modelado, Simulación y Optimización de Procesos Químicos.
Sifuentes, M. (2000). Simulación de Procesos en Ingeniería Químicia. México D.F.:
Plaza y Valdés Editores.
128
Proyecto Integrador Scortechini
Capítulo 6: Problemas y dificultades
Introducción
Durante la ejecución de este proyecto se encontraron algunos problemas y
dificultades que actuaron como restricciones. Algunos de ellos fueron resueltos,
otros se podrían resolver pero no se ha encontrado una solución satisfactoria y para
algunos otros no se conoce solución. A continuación se hará una descripción
detallada de estos inconvenientes.
Resolución de ecuaciones
Originalmente se había considerado la posibilidad de que el simulador fuera
orientado a ecuaciones. Como se explicó en el primer capítulo, en un producto de tal
naturaleza, se van generando ecuaciones en cada instancia del proceso (equipo u
operación). Estas ecuaciones se van acumulando en una estructura de datos, por
ejemplo una lista general de ecuaciones o un diccionario que tenga como claves los
nombres de cada equipo y como valores una lista con las ecuaciones pertenecientes
a cada uno, que pertenezca a un objeto de nivel superior a todos los equipos, en
nuestro caso el candidato ideal para eso es el objeto clase “Proyecto” que
representa al proceso como un todo.
Así, cada vez que se introduzca información o se realice alguna modificación en
algún equipo, se debería actualizar la lista de ecuaciones y una lista de incógnitas
asociada. Una vez que se reúna suficiente información acerca del proceso, éste
debería ser capaz de resolver todo el sistema de ecuaciones, o al menos parte de él.
Este enfoque permitiría plantear los balances de materia y energía de modo general
e igual para todos los equipos, sin hacer distinción entre ellos ni hacer
consideraciones especiales lo cual simplificaría mucho la tarea de programación.
Cuando se intentó implementar lo anterior, se hizo uso de la biblioteca Sympy de
Python. Esta librería contiene herramientas que permiten representar variables en
forma simbólica, plantear ecuaciones, simplificarlas y resolver sistemas de
129
Proyecto Integrador Scortechini
ecuaciones no lineales que son el caso más común y, también, el más difícil que se
presenta en los procesos en estado estacionario.
La función que se encarga de resolver sistemas de ecuaciones se llama “solve” y
recibe como primer argumento la lista de ecuaciones y como segundo argumento la
lista de incógnitas que debe tratar de despejar. Como respuesta devuelve un
diccionario incógnita:valor. Como método de resolución emplea principalmente el
método de Newton-Raphson, pero también tiene programados otros algoritmos
numéricos para casos especiales o para determinados tipos de problemas.
Lamentablemente no siempre se pudo resolver algunos tipos de ecuaciones
planteados, a veces ecuaciones simples como la ecuación de Antoine o las
ecuaciones de equilibrio de fases cuando se cumple la ley de Raoult; en otros casos
ecuaciones más complejas como aquellas que involucran coeficientes de actividad,
factores de compresibilidad o volúmenes molares a partir de ecuaciones de estado.
Se observó que esta limitación se presenta con alta frecuencia en casos de
ecuaciones que poseen más de una incógnita, y con menor frecuencia, en
ecuaciones de una incógnita. En otros casos, el tiempo de resolución se extendía de
manera inaceptable (30min a más de 1h).
La causa de estos inconvenientes puede ser una limitación en los algoritmos de
resolución.
Como consecuencia de esto, se tuvo que cambiar el enfoque de simulación desde
un simulador orientado a ecuaciones hacia uno híbrido, en el que se plantean
ecuaciones específicas para cada tipo de equipo. Para otros casos como los
cálculos de punto de rocío y de burbuja se tuvieron que programar algoritmos
particulares para esos problemas. Algo similar ocurrió con los cálculos de factores de
compresibilidad, coeficientes de fugacidad y de actividad. Además del incremento
considerable de la cantidad del código, también se produjo un notable incremento en
la complejidad del mismo, se tuvieron que agregar algoritmos de control y de
verificación para asegurarse de que las soluciones tuvieran significado físico (por
ejemplo temperaturas absolutas, volúmenes molares positivos, factores de
compresibilidad y volúmenes positivos y reales en vez de complejos, etc.).
Una ventaja derivada de esto fue un incremento en la eficiencia de resolución. Por
ejemplo, en un mezclador, si cualesquiera dos de sus corrientes tienen la misma
130
Proyecto Integrador Scortechini
temperatura y la misma concentración, y la temperatura de la tercera es
desconocida, ésta debe ser igual a la temperatura conocida y las corrientes son
isotérmicas. Se puede llegar a la misma conclusión haciendo un balance de energía,
pero este procedimiento es demasiado complejo para un caso tan simple. En cambio
se creó una subrutina que compare los valores de las temperaturas conocidas, si se
encuentra dos iguales, entonces establece el valor de la temperatura faltante igual al
valor de las otras dos.
Otra ventaja fue un mayor grado de detalle en el modelado de las operaciones.
Como desventaja se perdió la visión global del proceso. Esto fue una limitación
importante porque, en algunos casos, no se podían resolver todas las ecuaciones,
pero una consideración integral hubiera permitido resolver unas cuántas proveyendo
información suficiente para avanzar en la resolución de las restantes.
Una solución alternativa hubiera sido el desarrollo de una nueva biblioteca de
métodos numéricos, sin embargo es una tarea de complejidad considerable que
queda fuera del alcance de este proyecto, por eso se descartó esta posibilidad.
Niveles de iteración
Al no aplicarse un enfoque global de todo el proceso, la resolución de las ecuaciones
para ciertos tipos de procesos, como aquellos con derivación (bypass) y reciclo,
requiere de varios niveles de iteración. Por ejemplo, un nivel de iteración que
resuelva cálculos termodinámicos, otro nivel de iteración que resuelva las
ecuaciones particulares de cada equipo y un nivel superior de iteración que resuelva
las ecuaciones del proceso global. Los dos primeros niveles de iteración pudieron
programarse, pero no se tuvo éxito con el último nivel del proceso global.
Los principales inconvenientes fueron el aumento drástico del tiempo de cómputo,
debido a la necesidad de iterar a nivel del proceso y tener que revisar todos los
equipos de éste, y la entrada en ciclos infinitos que ocurría porque los datos de los
equipos no eran totalmente compatibles. Una pequeña perturbación (variación) en
los datos, hace que el método numérico produzca soluciones oscilantes con amplitud
creciente, de modo que se presenta la inestabilidad y la divergencia. Mientras la
131
Proyecto Integrador Scortechini
computadora sea capaz de representar los números resultantes continúa iterando,
pero nunca encuentra la solución, entonces se crea así el ciclo infinito del que no
sale nunca. Por lo que resulta necesario incorporar restricciones o elementos de
convergencia para subsanar este inconveniente. Por ejemplo, definir una tolerancia
del error y comparar los valores calculados con los de la iteración anterior; si el valor
absoluto de la diferencia es menor que la tolerancia establecida entonces se da por
finalizado el proceso de cálculo.
En el caso de bypass y de reciclo, sería factible crear un módulo especial que
agrupe varios componentes (corrientes, nodo divisor, mezclador) que simule estos
casos especiales cuando el mezclador y el nodo divisor están uno a continuación del
otro. También para esos casos, se presenta la necesidad de iterar a un nivel mayor y
se presenta el incremento del tiempo de cómputo y la aparición de ciclos infinitos.
Cálculo de temperaturas y balances de energía
La mayoría de las propiedades de las soluciones son funciones de la temperatura.
Cuando la temperatura del sistema es desconocida, las ecuaciones que se plantean
se vuelven grandes (con muchos términos), con expresiones racionales y
complicadas, lo que impide su resolución directa y dificulta mucho su resolución
numérica.
Esta situación se solucionó recurriendo a simplificaciones, por ejemplo considerar los
términos ideales y descartar los términos correctores, para obtener una solución
aproximada. Luego al comparar los resultados obtenidos con aquellos de cálculos
rigurosos se encontraron errores menores al 1% en los valores de entalpía y
menores al 5% en las temperaturas. Por lo tanto el problema se solucionó
adecuadamente.
Eliminación de equipos
Cuando se desea eliminar un equipo del proceso se debe seleccionar la opción
“Borrar” del menú contextual asociado a ese equipo. Este submenú genera un
132
Proyecto Integrador Scortechini
evento de menú que llama al método “OnBorrar”, éste tiene éxito al borrar el botón
imagen que representa al equipo en el diagrama de flujo, pero no logró conseguir la
eliminación del diccionario de “Equipos” del objeto “Proyecto” que representa al
proceso.
La razón detrás de este problema pertenece al dominio informático y no se ha
encontrado una solución.
Reconstrucción del diagrama de flujo
Cuando se abre un proyecto existente, se carga el objeto de clase “Proyecto” desde
el archivo donde se guardó el proceso. Sin embargo este objeto no es visible, ni
accesible, para el usuario. Entonces se procede a la reconstrucción del diagrama de
flujo. Para eso se invocan los métodos descriptos en capítulos anteriores para
generar los botones que representan a los equipos, sólo que este caso se omite el
diagnóstico del tipo de equipo, no se solicita el nombre ni se determinan las
coordenadas porque todo esto está almacenado dentro de cada objeto tipo equipo.
En la práctica se observa que los botones de todos los equipos de un mismo tipo
aparecen apilados en las mismas coordenadas, uno arriba del otro, forzando al
usuario a volver a acomodarlos en sus posiciones originales.
Se han ensayado soluciones para este problema pero todas fueron infructuosas y
generaron problemas mayores. Este problema también pertenece al campo de la
informática
Conexión de los equipos
En los simuladores comerciales los íconos de los equipos que están conectados por
líneas rectas o quebradas para indicar el flujo del proceso. Si bien Python posee
toda una biblioteca de dibujo, no se sistematizó el dibujo de estas interconexiones
entre los equipos por falta de tiempo. Sin embargo esto es un detalle meramente
visual que no afecta los cálculos.
133
Proyecto Integrador Scortechini
Capítulo 7: Conclusiones
Los hechos relatados y las experiencias acumuladas durante la ejecución de este
proyecto han permitido arribar a las siguientes conclusiones:
Fue posible crear un programa de computadora capaz de resolver los cálculos
asociados a las operaciones unitarias de transferencia de calor y de masa.
Se tuvo éxito al desarrollar una interface gráfica de usuario para el programa.
El autor de este proyecto se enriqueció fruto del aprendizaje de la
programación orientada a objetos y su aplicación a la Ingeniería Química.
Se crearon exitosamente objetos informáticos que representen corrientes de
proceso, nodos divisores, mezcladores, intercambiadores de calor y flashes.
La biblioteca Termodinámica que se desarrolló alcanzó un alto rendimiento en
el cálculo de propiedades.
Se programaron eficientemente el balance de materia y el de energía para los
equipos modelados.
La interface gráfica de usuario del programa simplifica y mejora la
comunicación con el usuario.
La calidad de los cálculos programados es comparable con la de los
simuladores comerciales.
El tiempo estimado para la ejecución del proyecto se ha visto triplicado.
Se obtuvo un programa que sirve adecuadamente como plataforma para su
aplicación a la mejora educativa.
Los resultados obtenidos pueden servir para el desarrollo de un producto
mejorado en el futuro.
El simulador creado es compatible con varios sistemas operativos gracias a
que está codificado utilizando software libre. Además pueden extenderse sus
funcionalidades agregando nuevos módulos que simulen otros equipos o tipos
de proceso.
Es necesario conocimiento y experiencia con métodos de Análisis Numérico
para poder comprender y mejorar las herramientas disponibles de resolución
de ecuaciones, ajuste de datos o de funciones, etc. Esos métodos no forman
parte del programa de la carrera en la actualidad.
134
Proyecto Integrador Scortechini
Para que el simulador funcione de forma más efectiva y que puedan
completarse muchas otras utilidades deseables para este programa, se
requerirá de un equipo multidisciplinario de profesionales.
La gestión y transmisión de la información entre objetos es una tarea crucial
para el buen funcionamiento del simulador. Lo anterior supone un trabajo de
programación importante y complejo, que si no hace correctamente o si es
mal interpretado, da origen a errores, pérdida de datos, genera trabajo
adicional, alarga los tiempos.
No fue posible lograr la propagación de la información entre los objetos que
simulan equipos de proceso cuando éstos no están directamente conectados.
A medida que aumenta la complejidad del proceso simulado se incrementa de
forma exponencial la sensibilidad de los sistemas de ecuaciones generados.
Muchas veces esto compromete la capacidad para llegar a una solución. Esta
dificultad es un problema de matemática aplicada para el cual no existe una
solución universal, sino que depende de técnicas avanzadas que varían con
el caso de estudio y quedan fuera del alcance de este proyecto.
135
Proyecto Integrador Scortechini
Anexo A: Cálculos Termodinámicos
Sistemas Ideales
Mezclas de gases ideales
Ejemplo 1: Una mezcla equimolar de gases ideales compuesta por metil etil cetona y
tolueno se encuentra a 50°C y 25kPa. Estimar las propiedades termodinámicas H, V,
S, G, U y A para la mezcla.
Primero se crea un objeto “BaseDeDatos” y luego un objeto “Proyecto”.
BDD = BaseDeDatos('BDD.xls')#Crea la Base de Datos
pro0 = Proyecto(BDD)#Crea el objeto Proyecto
A continuación se hace la configuración del sistema:
pro0.Sistema_Unidades = u'Sistema Internacional'
pro0.Lista_Compuestos = [u'Metil Etil cetona', u'Tolueno']
pro0.Tipo_Caudal = u'Molares'
pro0.Modelo_Liquido = u'Ideal'
pro0.Modelo_Gases = u'Ideal'
pro0.Nombre = 'pro1'
Después se establecen las condiciones de temperatura, presión y composición:
T = 323.15#K
P = 25000.0#Pa
z = {u'Metil Etil cetona':0.50, u'Tolueno':0.50}
Finalmente se arma una lista para indicar qué propiedades se desean obtener y se
crea un objeto de la clase “Ideal” al que se le manda esta información como
parámetro.
claves01 = [('Hiid', 'Hiid'), ('Hid', 'Hid'), ('Vid', 'Vid'), ('Uiid', 'Uiid'), ('Uid', 'Uid'),
('Siid', 'Siid'), ('Sid', 'Sid'), ('Giid', 'Giid'), ('Gid', 'Gid'), ('Aiid', 'Aiid'),
136
Proyecto Integrador Scortechini
('Aid', 'Aid')]
ideal1 = Ideal(pro0, T, P, sorted(z), [z[i] for i in sorted(z)], u"Gas", BDD, claves01)
La información de respuesta es:
Sistema [u'Metil Etil cetona', u'Tolueno'] Hiid= [ 27922.63 25643.13] Hid= 26782.88 Vid= 0.107466764 Uiid= [ 25235.96 22956.46] Uid= 24096.21 Siid= [ 90.37015358 76.76191955] Sid= 89.33 Giid= [-1280.49 837.52] Gid= -2084.11 Aiid= [-3967.16 -1849.15] Aid= -4770.78
Las variables con el subíndice “i” son listas que muestran las propiedades de las
especies individuales, en el orden en que aparecen en la lista “Sistema”. Las demás
variables tienen un único valor numérico que es la propiedad de la mezcla. El
subíndice “id” sirve para indicar que el sistema se comporta idealmente. Todos los
resultados están en unidades del Sistema Internacional.
La solución ideal
Ejemplo 2: Suponiendo que el sistema 2-propanol/agua conforme una solución ideal
30% molar de 2-propanol a 293K y 10000Pa. Calcular H, V, S, U, G y A.
Nuevamente se comienza creando un proyecto, se lo configura y después se arma
un objeto tipo “Ideal” al que se le pasan las especificaciones del problema.
pro1 = Proyecto(BDD)#Crea el objeto Proyecto
137
Proyecto Integrador Scortechini
#Configuración General
pro1.Sistema_Unidades = u'Sistema Internacional'
pro1.Lista_Compuestos = [u'Isopropanol', u'Agua']
pro1.Tipo_Caudal = u'Molares'
pro1.Modelo_Liquido = u'Ideal'
pro1.Modelo_Gases = u'Ideal'
pro1.Nombre = 'pro1'
#Especificación de T, P y composición
T = 293.0#K
P = 100000.0#Pa
z = {u'Isopropanol':0.30, u'Agua':0.70}
#SOLUCIÓN IDEAL
#Ideal-Ideal
Ideal2 = Ideal(pro1, T, P, sorted(z), [z[i] for i in sorted(z)], u"Líquido Subenfriado", BDD, claves01)
La respuesta obtenida es:
Sistema: [u'Isopropanol', u'Agua'] Hiid= [ -6051.38 -11036.01] Hid= -7546.77 Vid= 3.55731761232e-05 Uiid= [ -6053.19 -11043.66] Uid= -7550.33 Siid= [-18.14 -33.89] Sid= -17.79 Giid= [ -736.36 -1106.24] Gid= -2334.3 Aiid= [ -738.17 -1113.89] Aid= -2337.86
138
Proyecto Integrador Scortechini
Sistemas no ideales
Propiedades residuales
Ecuación del Virial
Ejemplo 3: Consideremos nuevamente la mezcla equimolar de metil etil cetona y
tolueno a 50° y 25kPa. Calculemos ahora las propiedades residuales de la mezcla y
de sus componentes.
Se repiten los pasos previos de configuración del sistema:
pro2 = Proyecto(BDD)
pro2.Sistema_Unidades = u'Sistema Internacional'
pro2.Lista_Compuestos = [u'Metil Etil cetona', u'Tolueno']
pro2.Tipo_Caudal = u'Molares'
pro2.Modelo_Liquido = u'Ideal'
pro2.Modelo_Gases = u'Virial'
pro2.Nombre = 'pro2'
#Especificación de T, P y composición
T = 323.15#K
P = 25000.0#Pa
z = {u'Metil Etil cetona':0.50, u'Tolueno':0.50}
claves2 = [('HiR', 'HiR'), ('HR', 'HR'), ('VR', 'VR'), ('UiR', 'UiR'), ('UR', 'UR'),
('SiR', 'SiR'), ('SR', 'SR'), ('GiR', 'GiR'), ('GR', 'GR'), ('AiR', 'AiR'), ('AR', 'AR')]
Luego se crea un objeto “Virial”:
virial1 = Virial(pro2, T, P, sorted(z), [z[i] for i in sorted(z)], u"Gas", BDD, claves2)
Los resultados devueltos son:
Sistema: [u'Metil Etil cetona', u'Tolueno']
HiR= [-128.42 -170.07]
HR= -149.11
VR= -0.00161839770276
UiR= [ -93.76 -123.59]
139
Proyecto Integrador Scortechini
UR= -108.54
SiR= [-0.2902 -0.3824]
SR= -0.3359
GiR= [-34.66 -46.48]
GR= -40.3
AiR= [ 0. 0.]
AR= 0.0
Algunos resultados obtenidos para la mezcla en “Introducción a la Termodinámica en
Ingeniería Química” de Smith, Van Ness y Abbot, 5° Edición, capítulo 13, página 540
son: HR= -149.0J/mol, SR= -0.3359J/(molK) y V= 0.10585m3/mol y como Vgi=
0.10747m3/mol entonces VR= -0.0162m3/mol. Todos los resultados concuerdan muy
bien.
Ecuaciones cúbicas de estado
Ejemplo 4: Ahora se resuelve el problema anterior utilizando las ecuaciones de
estado de Redlich-Kwong, Soave-Redlich-Kwong y de Peng-Robinson. Sólo se
presentan y se comparan los valores de las propiedades de la mezcla obtenidos con
el simulador.
Tabla 10. Comparación de propiedades residuales entre ecuaciones de
estado
Ecuación HR(J/mol) VR(m3/mol) SR(J/molK) UR(J/mol) GR(J/mol) AR(J/mol)
RK -68.08 -0.001028 -0.1315 -42.37 -25.59 0.1102
SRK -96.57 -0.001179 -0.2081 -67.10 -29.32 0.1451
PR -98.87 -0.001757 -0.2127 -54.95 -30.15 13.7746
Los resultados obtenidos por distintas ecuaciones de estado son consistentes entre
sí y con el modelo Virial. Las diferencias observadas entre ellos son inherentes a
cada modelo.
140
Proyecto Integrador Scortechini
Coeficiente de Actividad
Ejemplo 5: Para el sistema Acetona/Cloroformo/Metanol a 15°C y 250kPa calcular
los coeficientes de actividad. La composición molar es 15% Acetona, 25%
Cloroformo y 60% Metanol.
Para resolver este problema se aplicarán los modelos de Margules, de Van Laar y de
Wilson. Primero debe crearse un objeto clase proyecto, luego se debe configurar
cambiando el modelo de líquido en cada caso. Finalmente se crean los respectivos
objetos de la clase “Margules”, “Van Laar” o “Wilson”:
mar1 = Margules(s1, sci.array([z[i] for i in sorted(z)]), s1.BD['Actividad'])
vLr1 = VanLaar(s2, sci.array([z[i] for i in sorted(z)]), s2.BD['Actividad'])
wil = Wilson(s3, s3.BD['Actividad'], sci.array([z[i] for i in sorted(z)]), T,
sci.array([BDD.PM[i]/BDD.d[i] for i in sorted(z)]))
Los resultados devueltos por estos objetos se muestran a continuación:
MARGULES
Sistema: ['Acetona', 'Cloroformo', 'Metanol']
Matriz de coeficientes:
[[ 0. -0.8404 0.6184]
[-0.561 0. 0.832 ]
[ 0.5788 1.7365 0. ]]
lnGamma = [-0.0904 0.3513 0.0269]
Gamma = [ 0.9136 1.4209 1.0273]
VAN LAAR
Sistema: ['Acetona', 'Cloroformo', 'Metanol']
Matriz de coeficientes:
[[ 0. -0.8643 0.6184]
[-0.5899 0. 0.9356]
[ 0.5797 1.886 0. ]]
141
Proyecto Integrador Scortechini
lnGamma = [ 0.1411 0.4707 0.1099]
Gamma = [ 1.1515 1.6011 1.1162]
WILSON
Sistema: ['Acetona', 'Cloroformo', 'Metanol']
Matriz de coeficientes:
[[ 0. 485.8339464 -478.6692648]
[-2120.6683496 0. -1513.7477696]
[ 2281.5109328 7087.7968344 0. ]]
lnGamma = [ 0.0034 0.38402 0.15664]
Gamma = [ 1.0034 1.4682 1.1696]
Donde las filas y columnas de las matrices de coeficientes representan coeficientes
de interacción binaria entre compuestos y se corresponden con los compuestos de
forma exacta a como se han enumerado en la lista “Sistema”(1: Acetona, 2:
Cloroformo y 3: Metanol). El mismo orden se mantiene para las listas “lnGamma” y
“Gamma” que muestran el logaritmo natural del coeficiente de actividad y ese
coeficiente para cada compuesto de la mezcla.
142
Proyecto Integrador Scortechini
Anexo B: Cálculos de Corriente
Ejemplo 6: Una torre de fraccionamiento de petróleo obtiene 4000kmol/h de un
combustible con composición molar 80% de n-octano, 15% de n-heptano y el resto
n-hexano. El producto se enfría hasta 300K a una presión de 120kPa. Se desea
conocer la composición en masa, el peso molecular medio, el punto de burbuja, el
punto de rocío, el estado de agregación y las propiedades termodinámicas: H, S, G,
V, U y A molares de la mezcla. Utilizar el modelo del gas ideal para los gases y la
solución ideal para los líquidos.
Primero se debe abrir el simulador. Luego se debe hacer clic en la herramienta de
“Configuración General” de la barra de herramientas o en el menú “Configuración”
seleccionar el submenú “Configuración General”. Se abrirá entonces un diálogo, allí
se deben seleccionar las opciones: Sistema Internacional en Sistema de Unidades;
n-Heptano, n-Hexano y n-Octano en Lista de compuestos; Molares en Tipo de
Caudal; Ideal en Modelo para Gases y Modelo para Líquidos. La pantalla debe verse
así:
Figura 56. Configuración general para el Ejemplo 6.
Debe hacerse clic en el botón Aceptar.
143
Proyecto Integrador Scortechini
El próximo paso es crear un objeto Corriente haciendo clic sobre la herramienta con
forma de flecha o seleccionando la opción Corriente en el menú Insertar. Se abrirá
un diálogo que permite nombrar a la nueva corriente, ingresar un nombre, por
ejemplo F35, y hacer clic en Aceptar. Entonces aparecerá un ícono con forma de
flecha azul sobre el área de diseño. Al hacer clic con el botón derecho del mouse
aparecerá un menú emergente cerca del ícono. Cuando se selecciona la opción
Configurar se abre un diálogo de configuración de corriente.
Figura 57. Diálogo de configuración de corriente del Ejemplo 6.
Luego se debe escribir 4000 y seleccionar la opción kmol/h en Caudal; 300 y K en
Temperatura; 120000 y Pa en Presión; e introducir 0.15 y 0.80 en la tabla de
composición para n-heptano y n-octano respectivamente (el sistema calculará la
composición restante).
Figura 58. Completando los datos de la corriente.
144
Proyecto Integrador Scortechini
A continuación se debe hacer clic en el botón Actualizar y con la información provista
el programa resolverá la corriente.
Figura 59. Corriente del Ejemplo 6 resuelta.
Ejemplo 7: Una mezcla 50% de agua, 30% de metanol y el resto de acetona se
encuentra a 318K y 150000Pa. La composición se expresa en porcentaje en masa.
Se desea conocer el peso molecular medio de la solución, la composición molar, el
punto de burbuja, el de rocío, el estado de agregación y las propiedades
termodinámicas: entalpía, entropía, energía libre de Gibbs, volumen, energía interna
y energía de Helmholtz todas molares. Utilizar el modelo Virial para representar
gases y la ecuación de Wilson para modelar líquidos.
145
Proyecto Integrador Scortechini
Los pasos preliminares son los mismos que en ejemplo 6. Sólo que deben
seleccionarse Acetona, Agua y Metanol como componentes; Virial en Modelo para
Gases y Wilson en Modelo para Líquidos. Luego se introducen los datos del
problema en el diálogo de configuración de corriente y al hacer clic en Actualizar se
obtienen los resultados. Como el caudal es desconocido se debe introducir un
símbolo en su lugar, por ejemplo “Alim”.
Figura 60. Propiedades de la corriente del Ejemplo 7.
146
Proyecto Integrador Scortechini
Anexo C: Cálculos de Nodo Divisor
Ejemplo 8: Se desea dividir una corriente “A” de 350mol/h compuesta por Etanol y
Agua a una presión de 120kPa. Una de las corrientes (“B”) de producto tiene un
caudal de 218mol/h, la otra (“C”) se encuentra a 340K y está compuesta 30% por
Etanol. Determinar completamente las propiedades de presión y temperatura de
todas las corrientes, sus caudales y composiciones.
Primero se deben crear las corrientes y cargar la información conocida como se
ilustró en el Anexo B. Luego hay que crear un nodo divisor seleccionando el
submenú “Nodo Divisor” del menú “Insertar” o la herramienta con forma triangular
roja. Después de nombrar el nuevo equipo y hacer clic en la opción “Configurar” del
menú contextual se abrirá el diálogo de configuración del nodo divisor.
Figura 61. Diálogo de configuración de nodo divisor para el Ejemplo 8.
Después se debe seleccionar “A”, “B” y “C” como “Entrada”, “Salida 1” y “Salida 2”
respectivamente; y presionar el botón cargar.
147
Proyecto Integrador Scortechini
Figura 62. Carga de datos para el Ejemplo 8.
A continuación se debe presionar el botón “Actualizar” para intentar resolver el
problema o visualizar las incógnitas restantes y saber qué datos hay que ingresar.
Figura 63. Nodo divisor y corrientes del Ejemplo 8 resueltos.
148
Proyecto Integrador Scortechini
Anexo D: Cálculos de Mezclador
Ejemplo 9: Se tiene una corriente de 2300kg/h constituida 60% de Etileno, 30% de
Agua y el resto Dióxido de Carbono a 500K. Otra corriente se compone en un 50%
de Dióxido de Azufre y 50% de Monóxido de Carbono a 500kPa. Si estas corrientes
se mezclan para dar 5800kg/h de producto a 425K, encontrar el caudal de la
segunda alimentación y su temperatura, así como la composición de la corriente de
salida. Utilizar la ecuación de Soave-Redlich-Kwong como modelo de gas.
Primero se crean objeto corriente y se cargan los datos conocidos. Luego se agrega
un mezclador haciendo clic en la herramienta de mezclador (triángulo verde) o el
menú correspondiente y se abre el diálogo de configuración.
Figura 64. Diálogo de configuración de mezclador para el Ejemplo 9.
Después de seleccionar las corrientes, cargar los datos y actualizar el mezclador se
obtiene.
149
Proyecto Integrador Scortechini
Figura 65. Resultados del Ejemplo 9.
150
Proyecto Integrador Scortechini
top related