next up previous contents index
Siguiente: Diseño de la red Subir: Caso práctico: revamping de Anterior: Descripción del caso   Índice General   Índice de Materias


Análisis pinch básico

El diagrama de trama de la red de intercambiadores del caso base se muestra en la figura [*]. Se muestra el duty de cada cambiador, y las temperaturas en los extremos de cada unidad. Los datos de las corrientes se muestran en la tabla [*]. Como los rangos de temperatura eran muy amplios, las corrientes se han dividido en tramos de capacidad calorífica constante.

Figura: Red de intercambiadores de la unidad
Image crude2


Tabla: Datos de las corrientes del proceso
Corriente $ T $(^oC) $ \dot{m}\cdot C_P$(MW/^oC$ ^{-1}$)
1 349 $ -$
243 $ 0.215$
213 $ 0.197$
167 $ 0.178$
90 $ 0.168$
2 341 $ -$
210 $ 0.105$
172 $ 0.100$
111 $ 0.087$
65 $ 0.076$
3 268 $ -$
135 $ 0.065$
38 $ 0.054$
4 251 $ -$
169 $ 0.105$
77 $ 0.091$
5 235 $ -$
127 $ 0.008$
38 $ 0.007$
6 168 $ -$
136 $ 0.600$
118 $ 0.478$
108 $ 0.410$
71 $ 0.159$
7 136 $ -$
118 $ 0.256$
108 $ 0.210$
71 $ 0.159$
8 $ 15.6$ $ -$
121 $ 0.379$
9 120 $ -$
122 $ 0.400$
163 $ 0.422$
186 $ 0.600$
194 $ 0.725$
10 189 $ -$
237 $ 0.477$
265 $ 0.496$
368 $ 0.660$


Para realizar algunos de los cálculos vamos a auxiliarnos del entorno orientado a objetos PinchPython. En primer lugar, en el diseño de la nueva red de intercambiadores se eligió $ \Delta T_$min$ = 20$ ^oC. Con estos datos, podemos calcular los consumos óptimos del proceso, y compararlos con los consumos actuales. En el caso base, sin el horno adicional, se consumen $ 68.0$ MW de calefacción, y con el horno adicional $ 81.9$ MW. En cuanto a los consumos óptimos, los calcularemos con el siguiente programa: 

#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-

# Cálculo de los consumos óptimos de la unidad de destilación atmosférica
from PinchPython import *

# Función principal
def Main():
        # Tenemos 10 corrientes (pero divididas por tramos)

        c11 = Corriente()
        c12 = Corriente()
        c13 = Corriente()
        c14 = Corriente()

        c21 = Corriente()
        c22 = Corriente()
        c23 = Corriente()
        c24 = Corriente()

        c31 = Corriente()
        c32 = Corriente()

        c41 = Corriente()
        c42 = Corriente()

        c51 = Corriente()
        c52 = Corriente()

        c61 = Corriente()
        c62 = Corriente()
        c63 = Corriente()
        c64 = Corriente()

        c71 = Corriente()
        c72 = Corriente()
        c73 = Corriente()

        c81 = Corriente()

        c91 = Corriente()
        c92 = Corriente()
        c93 = Corriente()
        c94 = Corriente()

        c101 = Corriente()
        c102 = Corriente()
        c103 = Corriente()

        # Corriente 1 (por tramos)
        c11.setT0(349.)
        c11.setTf(243.)
        c11.setMCP(0.215)

        c12.setT0(243.)
        c12.setTf(213.)
        c12.setMCP(0.197)

        c13.setT0(213.)
        c13.setTf(167.)
        c13.setMCP(0.178)

        c14.setT0(167.)
        c14.setTf(90.)
        c14.setMCP(0.168)

        # Corriente 2 (por tramos)
        c21.setT0(341.)
        c21.setTf(210.)
        c21.setMCP(0.105)

        c22.setT0(210.)
        c22.setTf(172.)
        c22.setMCP(0.1)

        c23.setT0(172.)
        c23.setTf(111.)
        c23.setMCP(0.087)

        c24.setT0(111.)
        c24.setTf(65.)
        c24.setMCP(0.076)

        # Corriente 2 (por tramos)
        c31.setT0(268.)
        c31.setTf(135.)
        c31.setMCP(0.065)

        c32.setT0(135.)
        c32.setTf(38.)
        c32.setMCP(0.054)

        # Corriente 4 (por tramos)
        c41.setT0(251.)
        c41.setTf(169.)
        c41.setMCP(0.105)

        c42.setT0(169.)
        c42.setTf(77.)
        c42.setMCP(0.091)

        # Corriente 5 (por tramos)
        c51.setT0(235.)
        c51.setTf(127.)
        c51.setMCP(0.008)

        c52.setT0(127.)
        c52.setTf(38.)
        c52.setMCP(0.007)

        # Corriente 6 (por tramos)
        c61.setT0(168.)
        c61.setTf(136.)
        c61.setMCP(0.600)

        c62.setT0(136.)
        c62.setTf(118.)
        c62.setMCP(0.478)

        c63.setT0(118.)
        c63.setTf(108.)
        c63.setMCP(0.410)

        c64.setT0(108.)
        c64.setTf(71.)
        c64.setMCP(0.303)

        # Corriente 7 (por tramos)
        c71.setT0(136.)
        c71.setTf(118.)
        c71.setMCP(0.256)

        c72.setT0(118.)
        c72.setTf(108.)
        c72.setMCP(0.210)

        c73.setT0(108.)
        c73.setTf(71.)
        c73.setMCP(0.159)

        # Corriente 8 (sólo 1 tramo)
        c81.setT0(15.6)
        c81.setTf(121.)
        c81.setMCP(0.379)

        # Corriente 9 (por tramos)
        c91.setT0(120.)
        c91.setTf(122.)
        c91.setMCP(0.400)

        c92.setT0(122.)
        c92.setTf(163.)
        c92.setMCP(0.422)

        c93.setT0(163.)
        c93.setTf(186.)
        c93.setMCP(0.600)

        c94.setT0(186.)
        c94.setTf(194.)
        c94.setMCP(0.725)

        # Corriente 10 (por tramos)
        c101.setT0(189.)
        c101.setTf(237.)
        c101.setMCP(0.477)

        c102.setT0(237.)
        c102.setTf(265.)
        c102.setMCP(0.496)

        c103.setT0(265.)
        c103.setTf(368.)
        c103.setMCP(0.660)
        
        # La corriente ficticia nos permite tener acceso a todas las corrientes
        # que se hayan definido, y clasificarlas según su tipo (fría o caliente)
        corrientesFrias = corrienteFicticia.getListaDeCorrientesFrias()
        corrientesCalientes = corrienteFicticia.getListaDeCorrientesCalientes()

        # Creamos las curvas compuestas a partir de las corrientes
        curvaCompuestaFria = CurvaCompuesta(corrientesFrias)
        curvaCompuestaCaliente = CurvaCompuesta(corrientesCalientes)

        # Valor de ATMin
        ATMin = 20.0 # ºC

        # Creamos la tabla del problema, a partir de las curvas compuestas
        # y de ATMin
        tabla = TablaDelProblema(curvaCompuestaFria,curvaCompuestaCaliente,ATMin)
        
        # La tabla del problema nos proporciona esta información

        # Posición del punto pinch
        tPinch = tabla.getTemperaturaModificadaPinch()
        
        # Consumos óptimos del proceso
        qc = tabla.getQC()
        qh = tabla.getQH()
        
        # Presentación de los resultados
        print "T Pinch="+str(tPinch)+" ºC"
        print "QC ="+str(qc)+" MW"
        print "QH ="+str(qh)+" MW"


if '__main__' == __name__:
        Main()

La primera línea del programa indica que el contenido del programa debe pasarse al programa python, que es el que se encargará de ejecutarlo. En la segunda línea indicamos la codificación de caracteres adecuada para el idioma español (aunque en este programa no hay ninguna salida que contenga caracteres con tildes, etc, es una buena idea incluirlo en todos nuestros programas). Todas las líneas que comienzan con $ \char93 $ son comentarios, y son ignorados durante la ejecución del programa. Se ponen simplemente para mejorar la legibilidad del programa. Por tanto las dos primeras líneas son ignoradas a la hora de ejecutar el contenido del programa. Sólo tienen sentido para el sistema operativo.

En la siguiente línea de código, se incluye todo el código de la biblioteca PinchPython, que es el entorno orientado a objetos para realizar el análisis pinch de procesos químicos.

La siguiente línea crea la función principal del programa. En Python no es imprescindible poner una función principal, se puede poner el código directamente, pero es una buena idea estructurar el programa por si en un futuro queremos ampliarlo.

Dentro de la función, primero se crean las corrientes, después las curvas compuestas, después la tabla del problema, y finalmente se obtienen los consumos óptimos. Como puede verse, siempre se manejan los mismos conceptos (curva compuesta, tabla del problema, corriente fría, etc) que en un análisis pinch convencional. Además, la complejidad del programa es mínima, por lo que este entorno orientado a objetos es realmente una herramienta muy útil.

Una vez creado el programa, le damos permisos de ejecución con la orden 

chmod a+x revamping_uda

y después lo ejecutamos con 

 
./revamping_uda

Los resultados son: 

T Pinch=173.0 ºC
QC =42.6154 MW
QH =60.788 MW

Por tanto, si logramos diseñar una red de intercambiadores con el método pinch, el consumo de calefacción del proceso será un $ 35\%$ menor que el caso propuesto de añadir un horno.

next up previous contents index
Siguiente: Diseño de la red Subir: Caso práctico: revamping de Anterior: Descripción del caso   Índice General   Índice de Materias
2004-05-30