Simulador de Procesos Industrial

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


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


i


DEDICATORIA

Dedico este trabajo a mis padres quienes con esfuerzo, sacrificio y mucho amor me

han guiado durante toda mi vida.

ii


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


Í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


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


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


Í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


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


Í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


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


Í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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


𝑆̅𝑖(𝑇,𝑃)𝑔𝑖

= 𝑆𝑖(𝑇,𝑝𝑖)𝑔𝑖

= 𝑆𝑖(𝑇,𝑃)𝑔𝑖

− 𝑅 ∙ 𝑙𝑛(𝑦𝑖)


= �̅�𝑖(𝑇,𝑃)𝑔𝑖

− 𝑇 ∙ 𝑆̅𝑖(𝑇,𝑃)𝑔𝑖

= 𝐻𝑖(𝑇,𝑃)𝑔𝑖

− 𝑇 ∙ 𝑆𝑖(𝑇,𝑃)𝑔𝑖

+ 𝑅 ∙ 𝑇 ∙ 𝑙𝑛(𝑦𝑖)

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


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


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


𝐺𝑖𝑅 = 𝐺𝑖 − 𝐺𝑖

𝑔𝑖= 𝑅 ∙ 𝑇 ∙ 𝑙𝑛 (

𝑓𝑖𝑃)

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


𝐵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


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


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


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


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


𝐺𝑅

𝑅 ∙ 𝑇=∑𝑦𝑖

𝑁

𝑖=1

∙�̅�𝑖𝑅


𝑁

𝑖=1

∙ 𝑙𝑛(�̂�𝑖)

𝑉𝑅


𝑁

𝑖=1

∙�̅�𝑖𝑅


𝑁

𝑖=1

∙ [𝜕𝑙𝑛(�̂�𝑖)

𝜕𝑃]𝑇,𝑦

𝐻𝑅


𝑁

𝑖=1

∙�̅�𝑖𝑅

𝑅 ∙ 𝑇= −𝑇 ∙∑𝑦𝑖

𝑁

𝑖=1

∙ [𝜕𝑙𝑛(�̂�𝑖)

𝜕𝑇]𝑃,𝑦

𝑈𝑅


𝑁

𝑖=1

∙ (�̅�𝑖𝑅

𝑅 ∙ 𝑇−𝑃 ∙ �̅�𝑖

𝑅

𝑅 ∙ 𝑇) = −𝑇 ∙∑𝑦𝑖

𝑁

𝑖=1

∙ [𝜕𝑙𝑛(�̂�𝑖)

𝜕𝑇]𝑃,𝑦

− 𝑃 ∙∑𝑦𝑖

𝑁

𝑖=1

∙ [𝜕𝑙𝑛(�̂�𝑖)

𝜕𝑃]𝑇,𝑦

𝑆𝑅

𝑅=∑𝑦𝑖

𝑁

𝑖=1

∙ (�̅�𝑖𝑅

𝑅 ∙ 𝑇−�̅�𝑖𝑅

𝑅 ∙ 𝑇) = −𝑇 ∙∑𝑦𝑖

𝑁

𝑖=1

∙ [𝜕𝑙𝑛(�̂�𝑖)

𝜕𝑇]𝑃,𝑦

−∑𝑦𝑖

𝑁

𝑖=1

∙ 𝑙𝑛(�̂�𝑖)


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


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


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 ∙ 𝐵𝑖𝑗 − 𝐵𝑖𝑖 − 𝐵𝑗𝑗


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


𝑏 =∑𝑦𝑖 ∙ 𝑏𝑖

𝑁

𝑖=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


𝜕𝑎

𝜕𝑇=∑∑𝑦𝑖 ∙ 𝑦𝑗 ∙

𝜕𝑎𝑖𝑗

𝜕𝑇

𝑁

𝑗=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


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


𝑑 (𝑛𝐺𝐸

𝑅 ∙ 𝑇) =

𝑛𝑉𝐸

𝑅 ∙ 𝑇∙ 𝑑𝑃 −

𝑛𝐻𝐸

𝑅 ∙ 𝑇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


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


𝑀𝐸 = 𝑀𝑅 −∑𝑥𝑖 ∙ 𝑀𝑖𝑅

𝑁

𝑖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


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


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


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


Bibliografía

Henley-Seader. (2000). Operaciones de Separación por Etapas en Ingeniería

Química. México D.F.: Editorial Reverté S.A.



Oliver, E. D. (1968). Industrial & Engineering Chemistry Fundamentals.

Pedersen, C. (2007). Phase Behavior of Petroleum Reservoir Fluids. Taylor &

Francis Group.




Smith. (1997). Introducción a la Termodinámica en Ingeniería Química (5° Edición

ed.). México D.F.: McGraw Hill.

60


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


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


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


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


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


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


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


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


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


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


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


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


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


Figura 9. Pantalla de Configuración de HYSYS.

Figura 10. Otra pantalla de Configuración de HYSYS.

74


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


Tabla 6. Análisis de Nodo Divisor



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


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


“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


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


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


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


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


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


Entonces el recuento de variables y ecuaciones para el mezclador es:

Tabla 7. Análisis de Mezclador



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


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


∆𝐻𝑣𝑖(𝑇𝑏𝑢𝑟𝑏𝑢𝑗𝑎 𝑗) = ∆𝐻𝑣𝑖(𝑇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.


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


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


“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


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


lista desplegable y la asigna al atributo correspondiente (Entrada1, Entrada2 o

Salida) del mezclador, luego recupera del diccionario de “Equipos” del proceso los


mezclador. Después, hace una revisión de las propiedades y la composición de cada


en la celda apropiada de la tabla correspondiente que se muestra en pantalla.

107


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


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


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



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



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


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.


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”.


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


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.


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


112


“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



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


equipo. Después, hace una revisión de las propiedades y la composición de cada


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


Figura 42. Actualización y resolución de flash.

Figura 43. Representación de un flash en UNISIM.

115


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


Tabla9: Análisis de Intercambiador de Calor



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


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.


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”.


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


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


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


“DialogoIntercambiadorDeCalor”. El primer panel muestra el título del diálogo, el

119


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


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


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


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


Figura 50. Diálogo de Consulta a Biblioteca.

124


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


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


Figura 54. El menú Ayuda.

Figura 55. Diálogo Acerca de los Autores.

127


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.



HoneyWell. (2010). UNISIM Design. London.

Kern, D. Q. (1999). Procesos de Transferencia de Calor. México D. F.: CECSA.




128


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


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


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


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


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


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


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


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


('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


#Configuración General


pro1.Lista_Compuestos = [u'Isopropanol', u'Agua']



pro1.Modelo_Gases = u'Ideal'


#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


Sistemas no ideales

Propiedades residuales


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.Lista_Compuestos = [u'Metil Etil cetona', u'Tolueno']



pro2.Modelo_Gases = u'Virial'


#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


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.


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


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



[[ 0. -0.8643 0.6184]

[-0.5899 0. 0.9356]

[ 0.5797 1.886 0. ]]

141


lnGamma = [ 0.1411 0.4707 0.1099]

Gamma = [ 1.1515 1.6011 1.1162]

WILSON



[[ 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


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


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


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


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


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


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


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


Figura 65. Resultados del Ejemplo 9.

150


Documents

Simulador de Procesos Industrial