(Cinética e Reatores) O tempo de residência (\tau) é 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:
\tau=C_{A 0} \int_{X_{A 1}}^{X_{A 2}} \frac{1}{\left(-r_{A}\right)} d X_{A}
Onde C_{A 0} é a concentração inicial do reagente A, X_{A} é a fração de conversão e r_{A} é 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 ( X_{A} vs. 1 /\left(-r_{A}\right) ). Os dados experimentais abaixo foram coletados diretamente de um reator PFR.
X_{A} -r_{A}\left(\mathrm{~mol} \mathrm{~L}^{-1} \mathrm{~s}^{-1}\right)
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 C_{A 0}=5 \mathrm{~mol} / \mathrm{L}. 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 é X_{A 1}=0.05 e X_{A 2}=0.75.

Passo 1

O que o problema pede e os dados que temos.
  • Pede-se calcular o tempo de residência \tau num reator pistonado (PFR) usando os dados experimentais fornecidos, com C_{A0}=5\\ \mathrm{mol/L}.
  • A fórmula dada para \tau é
\tau = C_{A0} \int_{X_{A1}}^{X_{A2}} \frac{1}{\left(-r_A\right)}\, dX_A.
  • Os limites de integração são X_{A1}=0{,}05 e X_{A2}=0{,}75.
  • A tabela experimental (extraída do enunciado) contém pares (X_A,\\\ -r_A):
\begin{array}{|c|c|} \hline X_A & -r_A\\ (\mathrm{mol\\ L^{-1}\\ s^{-1}}) \\\ \hline 0{,}0 & 3{,}94 \\\ \hline 0{,}1 & 2{,}91 \\\ \hline 0{,}2 & 2{,}33 \\\ \hline 0{,}3 & 1{,}95 \\\ \hline 0{,}4 & 1{,}47 \\\ \hline 0{,}5 & 1{,}08 \\\ \hline 0{,}6 & 0{,}82 \\\ \hline 0{,}7 & 0{,}49 \\\ \hline 0{,}8 & 0{,}34 \\\ \hline \end{array}
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 \tau = C_{A0} \int_{X_{A1}}^{X_{A2}} \dfrac{1}{(-r_A)}\, dX_A diz: integramos a função f(X_A)=1/(-r_A) em X_A entre os limites e multiplicamos por C_{A0}.
  • Unidades: (-r_A) tem unidades \mathrm{mol\\ L^{-1}\\ s^{-1}}. Logo 1/(-r_A) tem unidades \mathrm{L\\ s\\ mol^{-1}}. Multiplicando por C_{A0} ( \mathrm{mol\\ L^{-1}}) resulta tempo (segundos). Boa checagem de unidade.
  • Porque temos dados discretos (apenas em pontos): precisamos interpolar os dados para avaliar 1/(-r_A) em pontos intermediários e então integrar numericamente. Duas etapas:
    1. Interpolação linear dos valores de -r_A como função de X_A (método simples, robusto e geralmente suficiente quando os pontos são razoavelmente próximos).
    2. 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).
  • Porque primeiro interpolamos -r_A e depois fazemos 1/(-r_A): isso segue o procedimento natural quando os dados nos dão a taxa. Se interpolássemos diretamente 1/(-r_A) 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 10^{-6} ou 10^{-8}).

Passo 3

Explicação didática da interpolação linear (o que é e como aplicamos na prática).
  • Interpolação linear entre dois pontos (x_0,y_0) e (x_1,y_1): para um x entre x_0 e x_1, o valor interpolado é
y(x) = y_0 + (y_1-y_0)\frac{x-x_0}{x_1-x_0}.
  • No nosso caso x \equiv X_A e y \equiv -r_A. 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 x_0<x_1<\dots<x_N e valores g(x_i), a aproximação pela regra composta dos trapézios é
\int_{x_0}^{x_N} g(x)\,dx \approx \sum_{i=0}^{N-1} \frac{g(x_i)+g(x_{i+1})}{2}\,(x_{i+1}-x_i).
  • 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 X, interpola -r_A, calcula 1/(-r_A) e faz a integração por trapézios;
    • faz iterações refinando a malha até convergência;
    • imprime o resultado final \tau (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.interp para interpolação linear; é rápida e segura para nosso caso.
    • A função np.trapz aplica a regra do trapézio composta sobre a malha regular.
    • A condição de segurança para rates_interp <= 0 garante 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 \text{tol}=10^{-8}. Esse critério geralmente garante alta precisão.

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 \tau, explique brevemente:
    • você fez interpolação linear dos dados de -r_A vs X_A;
    • avaliou 1/(-r_A) nos pontos interpolados;
    • integrou numericamente por trapézio no intervalo [0{,}05,0{,}75];
    • multiplicou por C_{A0}=5\\ \mathrm{mol/L}.
  • Se não der tempo de programar na prova, um método manual aceitável é:
    • interpolar / estimar -r_A 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.
  • 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.

Resposta

\tau = 3{,}116\\ \mathrm{s}

Exercícios relacionados