VIII Congresso Brasileiro de Engenharia Química em Iniciação Científica 27 a 30 de julho de 2009
Uberlândia, Minas Gerais, Brasil
MINIMIZAÇÃO DO CONSUMO DE ÁGUA EM PLANTAS COM
CONTAMINANTES USANDO UM ALGORITMO NÃO ITERATIVO
1 Marina Garcia Resende, 2 Valéria Viana Murata 1
Bolsista de iniciação Científica PIBIC/CNPq/UFU, discente do curso de Engenharia Química.
2
Professor da Faculdade de Engenharia Química da UFU/MG.
1,2
Faculdade de Engenharia Química da Universidade Federal de Uberlândia. Av João Naves de Ávila, 2121, Bloco 1K, Campus Santa Mônica, Uberlândia - MG, CEP 38408-100.
e-mail: valeria@ufu.br
RESUMO – Neste trabalho, o algoritmo proposto por SAVELSKI e BAGAJEWICZ (Savelski, M.J., Bagajewicz, M.J., 2001, Algorithmic procedure to design water utilization systems featuring a single contaminant in process plants, Chemical Engng. Science, 56, 1897-1911) para o projeto de redes de água com um contaminante, baseado em condições necessárias e suficientes de otimização, é aplicado no projeto de uma rede para minimização do consumo de alimentação de água fresca em processos industriais, levando em consideração as cargas inicial e final de contaminante de cada processo. O algoritmo tem caráter não iterativo, considera restrições nas concentrações de poluentes na entrada e na saída de cada processo além de uma carga de contaminante fixa e é aplicável a indústrias que operam com um único contaminante. Seus principais passos são: (1) identificação dos processos cuja concentração máxima de entrada é nula (head processes); (2) ordenação dos demais processos em ordem crescente da máxima concentração de saída; (3) aplicação do algoritmo de máximo reuso à lista obtida no passo (2). São apresentados os resultados obtidos para obtenção de uma rede ótima através da implementação do algoritmo em Maple® considerando quatro e seis processos, que satisfazem as condições necessárias de otimalidade do problema.
Palavras-Chave: otimização de processos, algoritmo não iterativo, minimização de águas residuárias.
INTRODUÇÃO
Os diversos problemas ambientais pelos quais o planeta Terra está passando atualmente são fruto de um despertar tardio da população mundial, que acreditava ser possível superar tais dificuldades sem o uso de políticas de preservação ambiental. Efeito estufa, mudanças constantes e bruscas de temperatura, carência de água e alimentos, furacões, tempestades devastadoras e outros fenômenos climáticos, são apenas algumas das conseqüências do descaso da população com as questões ambientais.
O desperdício de água em processos químicos e sua não reutilização contribuem para piorar ainda mais a situação da falta de água no planeta. A água é um dos bens mais indispensáveis aos seres vivos, tendo papel importante na maioria das reações químicas realizadas tanto no corpo humano, quanto nas indústrias.
Neste trabalho, o enfoque principal é a otimização do consumo de água e sua
conseqüente redução nas indústrias. A otimização é uma das ferramentas mais utilizadas na tomada de decisões por profissionais do mundo inteiro. Tratando-se de engenharia química, problemas como projeto de processos ou operação de plantas possuem uma infinidade de soluções.
Para milhares de indústrias a água é matéria-prima chave para a maioria de seus processos e frente à possibilidade de esgotamento deste recurso natural, torna-se essencial o desenvolvimento de estratégias de minimização do consumo e do desperdício e maximização do reuso de águas contaminadas e residuárias.
O trabalho de SAVELSKI e BAGAJEWICZ (2001) para o projeto de redes de água com um contaminante, baseado em condições necessárias e suficientes de otimização, é aplicado no projeto de uma rede para minimização do consumo de alimentação de água fresca em processos industriais, levando em consideração as cargas iniciais e finais de contaminante de cada processo.
O processo de design, o algoritmo e os resultados obtidos são apresentados a seguir.
ALGORITMO NÃO ITERATIVO PARA
PROJETOS DE REDES DE ÁGUA COM
UM CONTAMINANTE
Neste estudo de caso, foi escolhido o algoritmo não iterativo desenvolvido por SAVELSKI e BAGAJEWICZ (2001), capaz de prever uma rede ótima para minimização de águas residuárias.
O projeto proposto é o seguinte: dado um conjunto de processos usuários/consumidores de água, é preciso determinar uma rede de interconexões de correntes entre estes, de modo a minimizar o consumo total de água fresca, garantindo que todos os processos recebam água de qualidade adequada. O projeto da rede, o algoritmo e os resultados obtidos são apresentados a seguir.
Definições importantes
Os seguintes tipos de configurações de processos de uma rede de águas podem ser definidos:
• Fresh Water User Processes (FWU): processos que requerem água fresca. Podem também ser
consumidores de águas
residuárias;
• Wastewater User Processes (WWU): processos alimentados somente por águas residuárias;
• Head Processes (H): um caso especial de FWU que é alimentado somente por água fresca;
• Intermediate Wastewater User Processes (I): são processos alimentados por águas residuárias de outros processos e alimentam outros processos com as águas residuárias que produzem;
• Terminal Wastewater User Processes (T): processos alimentados por águas residuárias de outros processos, porém fornecem suas águas residuárias para tratamento; • Conjunto de precursores de um
processo j (Pj): é o conjunto de todos os processos que fornecem águas residuárias ao processo j; • Conjunto de recebedores de um
processo j (Rj): é o conjunto de todos os processos aos quais as águas residuárias do processo j são fornecidas;
• Load: carga mássica de contaminante (kg/h);
• Coutmáx: concentração de contaminante na água à saída do processo (ppm);
• Cinmáx: concentração de contaminante na água à entrada do processo (ppm);
• Fw[i]: vazão volumétrica de água fresca necessária para o processo i (kg/h);
• Total_agua: total de água fresca necessária para alimentar todos os processos da rede (kg/h);
• FTotal: vazão total de água (fresca e residuária) necessária para alimentação de todos os processos da rede (kg/h);
• K[i]: razão entre a carga mássica do processo i e a concentração máxima de saída de um precursor j;
• αj,i: um menos a razão entre a concentração máxima de saída do processo i e do processo j;
• Fj,i: vazão de água doada do processo j para o processo i (kg/h). Projeto da rede
O projeto da rede ótima de água segue os seguintes passos, respectivamente:
• Alimentar água fresca a todos os
processos que possuem
concentração inicial de contaminante igual a zero (processos HEAD). Caso nenhum dos processos se aplique ao caso, deve-se alimentar água ao processo que possuir menor concentração inicial de contaminante;
• Ordenar o restante dos processos em ordem crescente de concentração máxima de saída de contaminante; • Aplicar o algoritmo de máximo reuso
ao primeiro processo da lista. Excluir da lista de recursos todos os processos que violarem a condição ótima de monotonicidade; • Continuar aplicando a regra de máximo reuso do mesmo modo para todos os outros processos em questão.
Implementação do algoritmo em Maple 9.5® O algoritmo de máximo reuso foi aplicado por SAVELSKI e BAGAJEWICZ a um conjunto de
quatro processos. A implementação em Maple9.5® é mostrada na sequência. O primeiro elemento de cada lista representa o número que identifica cada processo. As sentenças em vermelho representam os dados fornecidos pelo usuário e os comandos de aplicação do algoritmo. Já as sentenças em azul, representam a solução fornecida pelo software. O algoritmo é aplicado inicialmente para quatro processos, considerados os seguintes dados de entrada:
Carga mássica de contaminante em kg/h (Load):
>Load:=[[1,2.0],[2,5.0],[3,30.0],[4,4.0]]; Load := [[1, 2.0], [2, 5.0], [3, 30.0], [4, 4.0]]
Concentração máxima de contaminante à entrada do processo (ppm):
>Cinmax:=evalf([[1,0.0*10^(-6)], [2,50.0*10^(-6)],[3,50*10^(-6)], [4,400*10^( -6)]]);
Cinmax := [[1., 0.00000000], [2., 0.5000000000e-4], [3., 0.5000000000e-0.5000000000e-4], [4.,0.4000000000e-3]]
Concentração máxima de contaminante à saída do processo (ppm): >Coutmax:=evalf([[1,100*10^(- 6)], [2,100*10^(-6)],[3,800*10^(-6)], [4,800*10^(-6)]]); Coutmax := [[1., 0.1000000000e-3], [2., 0.1000000000e-3], [3., 0.8000000000e-3], [4.,0.8000000000e-3]]
1º passo: Identificar os processos HEAD. O processo 1 é o único que possui concentração máxima de entrada igual a zero. Daí, pode-se calcular:
>Fw[1]:=Load[1][2]/Coutmax[1][2]; Fw[1] := 20000.00000
2º passo: Ordem crescente de concentração máxima de saída.
>for k from 1 by 1 to nops(Coutmax)-1 do for j from 1 by 1 to nops(Coutmax)-1 do if (Coutmax[j][2]>Coutmax[j+1][2]) then aux:=Coutmax[j]; Coutmax[j]:=Coutmax[j+1]; Coutmax[j+1]:=aux; end if; end do; end do;
for i from 1 by 1 to nops(Coutmax)-1 do print(Coutmax[i]); end do; [1., 0.1000000000e-3] [2., 0.1000000000e-3] [3., 0.8000000000e-3] [4., 0.8000000000e-3]
3º passo: Aplicação do algoritmo de máximo reuso.
O algoritmo é aplicado ao primeiro processo da lista (após o processo 1, pois este já foi identificado como HEAD), ou seja o processo 2. Percebe-se pela condição de monotonicidade que não há precursores possíveis para este processo, logo, também é um processo HEAD. Portanto, água fresca é alimentada ao processo 2.
>Fw[1]:=Load[2][2]/Coutmax[2][2]; Fw[1] := 20000.00000
Logo após, aplica-se o algoritmo ao processo 3. A concentração máxima de saída desse processo permite alimentá-lo com águas residuárias tanto do processo 1 quanto do processo 2. >K[3]:=Load[3][2]/Coutmax[3][2]; K[3] := 37500.00000 >alpha[1,3]:=1-(Coutmax[1][2]/Coutmax[3][2]); alpha[1, 3] := .87500000000 >F[1,3]:=(K[3]*Cinmax[3][2])/(Coutmax[1][2]-(1-alpha[1,3])*Cinmax[3][2]); F[1, 3] := 20000.00000 >if F[1,3]>Fw[1] then F[1,3]:=Fw[1]; end if; F[1, 3] := 20000.00000
De acordo com o algoritmo, toda a água do processo 1 deve ser doada ao processo 3.
>Fw[3]:=K[3]-F[1,3]*alpha[1,3]; Fw[3] := 20000.00000
Finalmente, considera-se o processo 4. Este processo tem apenas um precursor de acordo com a regra de monotonicidade, que é o processo 2. A concentração máxima de saída deste processo é menor do que a concentração máxima de entrada do processo 4, logo, este é candidato a WWU.
> Fw[4]:=0; Fw[4] := 0
> F[2,4]:=Load[4][2]/(Coutmax[4][2]-Coutmax[2][2]);
F[2, 4] := 5714.285714
A vazão total de água fresca necessária para alimentar todo o sistema é dada pelo somatório das vazões individuais::
>FTotal:=sum('FTotal[a]',a=1..nops(Coutmax)-1);
FTotal := 90000.00000
O algoritmo pode ser estendido a um número genérico de processos, como mostrado a seguir para um conjunto de seis processos,
Dados de entrada:
Carga mássica de contaminante em kg/h (Load):
>Load:=[[1,2.0],[2,5.0],[3,4.0],[4,5.0],[5,30.0],[6, 4.0]];
Load := [[1, 2.0], [2, 5.0], [3, 4.0], [4, 5.0], [5, 30.0], [6, 4.0]]
Concentração máxima de contaminante à entrada do processo (ppm): >Cinmax:=evalf([[1,25*10^(-6)], [2,25*10^(-6)],[3,25*10^(-6)], [4,50*10^( 6)], [5,50*10^(-6)], [6,400*10^(-6)]]); Cinmax := [[1., 0.2500000000e-4], [2., 0.2500000000e-4], [3., 0.2500000000e-4], [4.,0.5000000000e-4], [5., 0.5000000000e-4], [6., 0.4000000000e-3]]
Concentração máxima de contaminante à saída do processo (ppm): >Coutmax:=evalf([[1,80*10^(- 6)], [2,100*10^(-6)],[3,200*10^(-6)], [4,100*10^(-6)],[5,800*10^(-6)], [6,800*10^(-[4,100*10^(-6)],[5,800*10^(-6)],[7,10000]]); Coutmax := [[1., 0.8000000000e-4], [2., 0.1000000000e-3], [3., 0.2000000000e-3], [4.,0.1000000000e-3], [5., 0.8000000000e-3], [6., 0.8000000000e-3], [7., 10000.]]
1º passo do algoritmo: Ordem crescente de concentração máxima de saída (ligado à condição de optimalidade de monotonicidade):
>for k from 1 by 1 to nops(Coutmax)-1 do for j from 1 by 1 to nops(Coutmax)-1 do if (Coutmax[j][2]>Coutmax[j+1][2]) then aux:=Coutmax[j]; Coutmax[j]:=Coutmax[j+1]; Coutmax[j+1]:=aux; end if; end do; end do;
for i from 1 by 1 to nops(Coutmax)-1 do print(Coutmax[i]); end do; [1., 0.8000000000e-4] [2., 0.1000000000e-3] [4., 0.1000000000e-3] [3., 0.2000000000e-3] [5., 0.8000000000e-3] [6., 0.8000000000e-3]
O algoritmo fornece o processo 1 como primeiro processo da nova lista. Este, sempre será HEAD, conseqüentemente, sua concentração inicial é zero e a vazão de alimentação de água fresca pode ser calculada da seguinte forma: >Fw[1]:=Load[1][2]/Coutmax[1][2]; Fw[1] := 25000.00000 >Cinmax[1][2]:=0; Cinmax[1][2] := 0 >Ftotal[1]:=Fw[1]; FTotal[1] := 25000.00000
2º Passo: Deve-se fornecer água fresca aos demais usuários da rede:
>Fw[2]:=Load[2][2]/Coutmax[2][2]; Fw[2] := 50000.00000 >Fw[4]:=Load[4][2]/Coutmax[3][2]; Fw[4] := 50000.00000 >Fw[3]:=Load[3][2]/Coutmax[4][2]; Fw[3] := 20000.00000 >Fw[5]:=Load[5][2]/Coutmax[5][2]; Fw[5] := 37500.00000
3º Passo: Maximizar o uso de águas residuárias do 2º passo. Aplicar o algoritmo de máximo reuso (menor concentração de saída): Obs: Os processos 1 e 2 são HEAD, ou seja, são alimentados somente com água fresca e suas concentrações iniciais de entrada caem para
zero, não atingindo seus valores máximos (ambos iguais a 25ppm). Logo, calcula-se a quantidade de água fresca necessária para a alimentação do processo 2 de forma análoga ao processo 1.
> Cinmax[2][2]:=0; Cinmax[2][2] := 0 > Fw[2]; 50000.00000 > FTotal[2]:=Fw[2]; FTotal[2] := 50000.00000
Análise de cada processo:
A análise é feita baseada na ordem crescente de concentração máxima de saída.
O processo 4 é do tipo I ou seja, é alimentado com águas residuárias de outros processos, doa água residuária e é também alimentado com água fresca. De acordo com o algoritmo de design, o primeiro e único precursor possível é o processo 1, pois é o único que possui concentração inicial máxima de saída menor e diferente do processo 4 (o processo 2 possui a mesma concentração de saída, logo, não pode ser usado).
>K[4]:=Load[4][2]/Coutmax[3][2]; K[4] := 50000.00000 >alpha[1,4]:=1-(Coutmax[1][2]/Coutmax[3][2]); alpha[1, 4] := .2000000000 >F[1,4]:=(K[4]*Cinmax[4][2])/(Coutmax[1][2]-(1-alpha[1,4])*Cinmax[4][2]); F[1, 4] := 62500.00000 >if F[1,4]>Fw[1] then F[1,4]:=Fw[1]; end if; F[1, 4] := 25000.00000
De acordo com o algoritmo, toda a água do processo 1 deve ser doada ao processo 4.
>Fw[4]:=K[4]-F[1,4]*alpha[1,4]; Fw[4] := 45000.00000 >FTotal[4]:=Fw[4]+F[1,4]; FTotal[4] := 70000.00000 >Cinmax[4][2]:=F[1,4]*Coutmax[1][2]/FTotal[4]; Cinmax[4][2] := 0.2857142857e-4
O processo 3 é do tipo T, ou seja, é alimentado com águas residuárias de outros processos, porém, eliminam suas águas residuárias para tratamento. São também alimentados com água fresca. Consideremos o processo 4 como primeiro precursor, pois possui a maior vazão de água disponível para doação (70000 kg/h contra 50000 do processo 2). >K[3]:=Load[3][2]/Coutmax[4][2]; K[3] := 20000.00000 >alpha[4,3]:=1-Coutmax[3][2]/Coutmax[4][2]; alpha[4, 3] := .5000000000 >F[4,3]:=(K[3]*Cinmax[3][2])/(Coutmax[3][2]-(1-alpha[4,3])*Cinmax[3][2]); F[4, 3] := 5714.285714 >Fw[3]:=K[3]-F[4,3]*alpha[4,3]; Fw[3] := 17142.85714 >FTotal[3]:=Fw[3]+F[4,3]; FTotal[3] := 22857.14285 >Cinmax[3][2]:=F[4,3]*Coutmax[3][2]/FTotal[3]; Cinmax[3][2] := 0.2500000001e-4
O processo 5 é um processo do tipo T. Usando um raciocínio análogo ao do processo 3, vamos considerar o processo 4 como possível precursor: > K[5]:=Load[5][2]/Coutmax[5][2]; K[5] := 37500.00000 >alpha[4,5]:=1-Coutmax[3][2]/Coutmax[5][2]; alpha[4, 5] := .8750000000 >F[4,5]:=(K[5]*Cinmax[5][2])/(Coutmax[3][2]-(1-alpha[4,5])*Cinmax[5][2]); F[4, 5] := 20000.00000 >Fw[5]:=K[5]-F[4,5]*alpha[4,5]; Fw[5] := 20000.00000 >FTotal[5]:=Fw[5]+F[4,5]; FTotal[5] := 40000.00000 >Cinmax[5][2]:=F[4,5]*Coutmax[3][2]/FTotal[5]; Cinmax[5][2] := 0.5000000000e-4
O processo 6 é do tipo WWU, logo, é alimentado somente com águas residuárias de outros processos.
> Fw[6]:=0; Fw[6] := 0
Supondo que o processo 4 seja o precursor:
> F[4,6]:=Load[6][2]/(Coutmax[6][2]-Coutmax[3][2]); F[4, 6] := 5714.285714 >FTotal[6]:=F[4,6]; FTotal[6] := 5714.285714 >Cinmax[6][2]:=F[4,6]*Coutmax[3][2]/F[4,6]; Cinmax[6][2] := 0.1000000000e-3
A quantidade total de água fresca utilizada em todos os processos e a vazão total de água utilizada por todos os processos, são, respectivamente: >Total_agua:=sum('Fw[u]',u=1..nops(Coutmax) -1); Total_agua := 157142.8571 >FTotal:=sum('FTotal[a]',a=1..nops(Coutmax)-1); FTotal := 213571.4285
As Figs. (1) e (2), a seguir, mostram a rede ótima encontrada através da implementação so algoritmo de máximo reuso em Maple®,
coincidindo com as soluções encontradas por SAVELSKI e BAGAJEWICZ.
Figura 1. Rede ótima encontrada através da implementação em Maple® do algoritmo de máximo reuso para um sistema de quatro processos.
Figura 2. Rede ótima encontrada através da implementação em Maple® do algoritmo de máximo reuso para um sistema de
seis processos.
CONCLUSÃO
O algoritmo não iterativo consegue minimizar o consumo de águas residuárias de maneira simples, mostrando-se ser um método eficiente. O software MAPLE® é capaz de reproduzi-lo de forma satisfatória, contribuindo, principalmente, com a redução do tempo de aplicação deste algoritmo pelo usuário.
AGRADECIMENTOS
Ao CNPq (Conselho Nacional de Desenvolvimento Científico e Tecnológico) e ao PIBIC/CNPq/UFU (Programa Institucional de Bolsa de Iniciação Científica) pelo apoio financeiro.
REFERÊNCIAS BIBLIOGRÁFICAS
ALVA ARGÁEZ A., KOKOSSIS A.C. e SMITH R.,1998, Wastewater minimization of industrial systems using an integrated approach, Computers Chemical Engineering, Vol. 22, p.741-744.
BEHDANI B., PISHVAIE M. R., and RASHTCHIAN D., 2007, Optimal scheduling of mixed batch and continuous processes incorporating utility aspects, Chemical Engineering and Processing, Volume 46, Tópico 4, Abril, p. 271-281
SAVELSKI, M. J., e BAGAJEWICZ, M. J. , 2000, On the optimality conditions of water utilization in process plants with single contaminants, Chemical Engineering Science. 55(21), 5035-5048.
SAVELSKI, M. J., e BAGAJEWICK, M. J. , 2001, Algorithmic procedure to design water utilization systems featuring a single contaminant in process plants, Chemical Engineering Science. 56, 1897-1911.
SMITH, R. e WANG, Y. P., 1994, Wastewater minimization, Chemical Engineering Science, Vol. 49, n°7, p.981-1006.
