(Cinética e Reatores) O tempo de residência
é um parâmetro importante no projeto de reatores químicos. Se considerarmos um reator ideal de escoamento pistonado (plug flow reactor - PFR), podemos escrever um balanço de massa e obter a seguinte equação:
Onde
é a concentração inicial do reagente
é a fração de conversão e
é a taxa de reação. O tempo de residência pode ser calculado plotando a fração de conversão contra o inverso da taxa de reação (
vs.
). Os dados experimentais abaixo foram coletados diretamente de um reator PFR.
0.0
3.94
0.1
2.91
0.2
2.33
0.3
1.95
0.4
1.47
0.5
1.08
0.6
0.82
0.7
0.49
0.8
0.34
Escreva um código Python para calcular o tempo residencial em um PFR ideal usando os dados da tabela acima e assumindo uma concentração inicial
. Seu código deve usar interpolação dos dados e integração com múltiplos trapezóides até obter uma acurácia razoável. O intervalo de integração é
e
.
|
|
|
| 0.0 | 3.94 |
| 0.1 | 2.91 |
| 0.2 | 2.33 |
| 0.3 | 1.95 |
| 0.4 | 1.47 |
| 0.5 | 1.08 |
| 0.6 | 0.82 |
| 0.7 | 0.49 |
| 0.8 | 0.34 |
Passo 1
O que o problema pede e os dados que temos.
- Pede-se calcular o tempo de residência
num reator pistonado (PFR) usando os dados experimentais fornecidos, com . - A fórmula dada para
é
- Os limites de integração são
e . - A tabela experimental (extraída do enunciado) contém pares
:
Observações do passo 1: listo explicitamente o que é pedido e os dados; a resolução numérica começa no passo seguinte.
Passo 2
Entendendo a equação e a estratégia numérica (aula curta e intuitiva).
- A fórmula
diz: integramos a função em entre os limites e multiplicamos por . - Unidades:
tem unidades . Logo tem unidades . Multiplicando por ( ) resulta tempo (segundos). Boa checagem de unidade. - Porque temos dados discretos (apenas em pontos): precisamos interpolar os dados para avaliar
em pontos intermediários e então integrar numericamente. Duas etapas: - Interpolação linear dos valores de
como função de (método simples, robusto e geralmente suficiente quando os pontos são razoavelmente próximos). - Integração numérica usando a regra dos trapézios composta (dividir o intervalo em muitos subintervalos, aproximar em cada subintervalo pela média dos valores nas extremidades).
- Interpolação linear dos valores de
- Porque primeiro interpolamos
e depois fazemos : isso segue o procedimento natural quando os dados nos dão a taxa. Se interpolássemos diretamente também seria possível; aqui prefiro interpolar a taxa (mais linear) e depois inverter, mas qualquer das duas abordagens linearmente consistentes dá resultado semelhante para passos pequenos. - Critério de acurácia: aumentar o número de subintervalos até que o resultado convirja (mudança relativa menor que uma tolerância, por exemplo
ou ).
Passo 3
Explicação didática da interpolação linear (o que é e como aplicamos na prática).
- Interpolação linear entre dois pontos
e : para um entre e , o valor interpolado é
- No nosso caso
e . A interpolação linear é simples, rápida e reproduz exatamente os valores nos nós dados. - Em Python usaremos uma rotina de interpolação linear já pronta (por exemplo,
numpy.interp) que implementa exatamente essa fórmula de maneira vetorizada e eficiente.
Passo 4
A regra composta dos trapézios (aula curta e fórmula).
- Para um conjunto de pontos
e valores , a aproximação pela regra composta dos trapézios é
- Intuição: em cada subintervalo aproximamos a curva por um segmento reto e a área por um trapézio.
- Se a malha for refinada (mais subintervalos), a aproximação melhora. Vamos implementar um laço que duplica o número de subintervalos até que a variação relativa entre duas integrações consecutivas fique abaixo de uma tolerância.
Passo 5
Código Python comentado que implementa tudo (interpolação + trapézio composto + critério de convergência).
- O código abaixo:
- define os dados fornecidos;
- cria uma função que, para uma malha
, interpola , calcula e faz a integração por trapézios; - faz iterações refinando a malha até convergência;
- imprime o resultado final
(em segundos) e o número de pontos usados.
import numpy as np
# Dados experimentais (extraídos da tabela do enunciado)
X_nodes = np.array([0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])
rates_nodes = np.array([3.94, 2.91, 2.33, 1.95, 1.47, 1.08, 0.82, 0.49, 0.34]) # este é -r_A
# Constantes do problema
C_A0 = 5.0 # mol/L
X1 = 0.05
X2 = 0.75
def integrate_tau(X1, X2, X_nodes, rates_nodes, C_A0, N):
"""
Calcula integral usando N pontos igualmente espaçados em [X1,X2].
Procedimento:
- interpola linearmente 'rates_nodes' (que são -r_A) nos pontos da malha
- calcula f(X) = 1/(-r_A) = 1/rates_interpolated
- integra f(X) por trapézio
- retorna tau = C_A0 * integral
"""
X_grid = np.linspace(X1, X2, N)
# Interpolação linear dos rates (numpy.interp usa exatamente a fórmula linear)
rates_interp = np.interp(X_grid, X_nodes, rates_nodes)
# Segurança: evitar divisão por zero (não esperado com esses dados, mas por precaução)
if np.any(rates_interp <= 0):
raise ValueError("Algum valor interpolado de -r_A é <= 0, confira os dados.")
inv_rates = 1.0 / rates_interp # f(X) = 1/(-r_A)
integral = np.trapz(inv_rates, X_grid)
tau = C_A0 * integral
return tau
# Estratégia de convergência: aumentar N até mudança relativa < tol
tol = 1e-8
N = 50 # malha inicial (já razoável)
tau_old = integrate_tau(X1, X2, X_nodes, rates_nodes, C_A0, N)
max_iter = 20
for i in range(max_iter):
N *= 2
tau_new = integrate_tau(X1, X2, X_nodes, rates_nodes, C_A0, N)
rel_change = abs(tau_new - tau_old) / max(1e-16, abs(tau_new))
# print progresso (opcional)
# print(f"iter {i+1}: N={N}, tau={tau_new:.8f}, rel_change={rel_change:.2e}")
if rel_change < tol:
tau_final = tau_new
N_final = N
break
tau_old = tau_new
else:
# se não convergir dentro de max_iter, usa o último valor
tau_final = tau_new
N_final = N
# Impressão do resultado final
print(f"Tempo de residência: tau = {tau_final:.8f} s (convergiu com N = {N_final} pontos)")
- Comentários sobre o código:
- Usei
numpy.interppara interpolação linear; é rápida e segura para nosso caso. - A função
np.trapzaplica a regra do trapézio composta sobre a malha regular. - A condição de segurança para
rates_interp <= 0garante que não dividimos por zero (não ocorrerá com os dados dados, mas é boa prática). - O laço de convergência dobra o número de pontos até a mudança relativa ficar abaixo de
. Esse critério geralmente garante alta precisão.
- Usei
Passo 6
Como interpretar e usar o resultado na prova (dicas práticas e cheias de empatia).
- Na prova: se perguntarem só o valor numérico de
, explique brevemente: - você fez interpolação linear dos dados de
vs ; - avaliou
nos pontos interpolados; - integrou numericamente por trapézio no intervalo
; - multiplicou por
.
- você fez interpolação linear dos dados de
- Se não der tempo de programar na prova, um método manual aceitável é:
- interpolar / estimar
em alguns nós-chave dentro do intervalo e então aplicar regra dos trapézios manualmente com esses poucos segmentos (como mostrei na ideia). Mas claro que programar é mais seguro e rápido se for permitido.
- interpolar / estimar
- Incentivo rápido: tá fazendo a coisa certa pedindo interpolação + trapézio. Foca em praticar isso umas duas vezes com outros conjuntos de dados que teu prof indicar — depois fica automático na prova.