Supertargeting

En esta sección vamos a escribir un programa para calcular el valor de $\Delta T_$min que logra un coste mínimo de la red. De este modo, al realizar el diseño pinch con este valor, la red tendrá un coste mínimo y un consumo energético óptimo. Esto es lo que se conoce como supertargeting.

En esta sección vamos a repetir el ejemplo . Vamos a iniciar un programa nuevo, aunque muchas de las partes serán similares al programa anterior.

Explicaremos el programa por partes. La primera parte es similar a ejemplos anteriores:

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

from PinchPython import *
import os

c1 = Corriente()
c2 = Corriente()
c3 = Corriente()
c4 = Corriente()
vapor = Corriente()
agua = Corriente()

c1.setT0(20.)
c1.setTf(180.)
c1.setMCP(0.2)
c1.setCoeficientePelicula(0.0006)

c2.setT0(250.)
c2.setTf(40.)
c2.setMCP(0.15)
c2.setCoeficientePelicula(0.0010)

c3.setT0(140.)
c3.setTf(230.)
c3.setMCP(0.3)
c3.setCoeficientePelicula(0.0008)

c4.setT0(200.)
c4.setTf(80.)
c4.setMCP(0.25)
c4.setCoeficientePelicula(0.0008)

vapor.setT0(240.)
vapor.setTf(239.)
vapor.setMCP(7.50)
vapor.setCoeficientePelicula(0.0030)

agua.setT0(20.)
agua.setTf(30.)
agua.setMCP(1.)
agua.setCoeficientePelicula(0.0010)

Ahora definiremos las corrientes frías y calientes para las curvas compuestas no balanceadas, que se emplearán para el cálculo de la temperatura del punto pinch:

corrientesFrias = [c1, c3]
corrientesCalientes = [c2, c4]

Es necesario definir algunas listas donde guardaremos los resultados que se vayan calculando:

lista_At = []
lista_coste_area = []
lista_coste_energia = []
lista_coste_total = []

Y antes de comenzar el bucle de optimización, fijaremos el valor inicial de $\Delta T_$min:

At = 2.0 # ºC

En este punto vamos a comenzar a escribir el bucle, que para cada valor de $\Delta T_$min calculará el área de la red y los consumos del proceso, y después los costes. El valor de $\Delta T_$min para un coste mínimo es el óptimo.

while At<45.0:
        cFria = CurvaCompuesta(corrientesFrias)
        cCaliente = CurvaCompuesta(corrientesCalientes)
        tabla = TablaDelProblema(cFria,cCaliente,At)
        tPinch = tabla.getTemperaturaModificadaPinch()
        qc = tabla.getQC()
        qh = tabla.getQH()
        agua.setMCP(qc/10.)
        vapor.setMCP(qh)
        cFria_bal = CurvaCompuesta([c1,c3,agua])
        cCaliente_bal = CurvaCompuesta([c2,c4,vapor])
        red = RedIntercambiadores(cFria_bal,cCaliente_bal,tPinch,At)
        N_sp = red.getNumeroMinimoIntercambiadoresSobrePinch()
        N_bp = red.getNumeroMinimoIntercambiadoresBajoPinch()
        N = N_sp + N_bp

        try:
                area = red.getAreaRedMonopaso()
        except:
                print "Error calculando area."
                area = -999

        if area > 0:
                coste_area = N*(10552. + 131.9*area/N)
                coste_energia = 120000.*qh + 10000.*qc
                lista_coste_area.append(coste_area)
                lista_coste_energia.append(coste_energia)
                lista_coste_total.append(coste_area+coste_energia)
                lista_At.append(At)

        At += 0.5

En este bucle calculamos la temperatura del punto pinch para cada caso, fijamos el consumo adecuado de cada servicio auxiliar, y calculamos el área de la red. Si no se ha producido ningún error en el cálculo del área, calculamos cada coste y guardamos los resultados en su lista correspondiente. El bucle continúa con un pequeño incremento de $\Delta T_$min.

Una vez que ha terminado el bucle, podemos hallar el valor óptimo de $\Delta T_$min, y escribir los resultados en un fichero para representarlos gráficamente.

posicion_optimo = lista_coste_total.index(min(lista_coste_total))
At_optimo = lista_At[posicion_optimo]

file = open('supertargeting','w')
for i in range(len(lista_coste_area)):
        file.write(str(lista_At[i])+'\t'\
                +str(lista_coste_area[i])+'\t'\
                +str(lista_coste_energia[i])+'\t'+\
                str(lista_coste_total[i])+'\n')

file.close()

print "Archivo terminado"
print "ATMin optimo = "+str(At_optimo)+" ºC"

Una vez que se ha terminado el fichero de resultados, podemos representarlo gráficamente con Gnuplot. En este caso, la imagen estará en el fichero optimo.png.

comando = 'echo "set terminal png small; set size .65; \
        set grid; set output \'optimo.png\';\
        set ylabel \'T (C)\'; set xlabel \'H (MW)\';\
        plot \'supertargeting\' using 1:2 with lines title \'Coste cambiadores\''

comando += ", 'supertargeting' using 1:3 with lines title 'Coste energia'"

comando += ", 'supertargeting' using 1:4 with lines title 'Coste total'"

comando += '"| gnuplot'

os.system(comando)

Al ejecutar este programa, se produce la siguiente salida de resultados:

Error calculando area.
Error calculando area.
Error calculando area.
Error calculando area.
Error calculando area.
Archivo terminado
ATMin optimo = 10.0 ºC

Como vemos, en algunos casos se ha producido errores en el cálculo del área. Hay que tener en cuenta que para valores muy altos de $\Delta T_$min el número de unidades de la red tiende a cero, y se pueden producir errores al dividir por este parámetro. La gráfica, similar a la figura , obtenida con el programa se muestra en la figura .

Figura: Gráfica de costes totales vs. $\Delta T_$min, obtenida con el programa de ejemplo