CFD com Python: da Teoria ao Código

Introdução

Apesar de ser uma linguagem interpretada, o Python vem ganhando cada vez mais espaço em aplicações de alto desempenho, como a Dinâmica dos Fluidos Computacional (CFD). Seu sucesso se deve ao ecossistema robusto de bibliotecas otimizadas como NumPy, SciPy e Matplotlib, que tornam a prototipagem científica ágil e eficiente.

Comparado ao MATLAB, Python frequentemente oferece melhor performance, maior flexibilidade e, o mais importante, é gratuito e open-source, o que o torna ideal para pesquisadores, engenheiros e estudantes que desejam implementar simulações e resolver problemas reais de engenharia com precisão e eficiência.

Neste post, vamos resolver um problema clássico de condução térmica estacionária em uma placa 1D, aplicando passo a passo: teoria → discretização → código → gráfico.

1. O problema físico a ser resolvido com Python

Queremos resolver a equação da condução térmica unidimensional em regime estacionário:

Para uma placa de 1 metro de comprimento, com as seguintes condições de contorno:

• ,
• 

A solução analítica é uma função linear simples:

Nosso objetivo é resolver numericamente esse problema com Python e comparar com essa solução analítica.

2. Pré-processamento: Discretização com Diferenças Finitas

Utilizaremos o método das diferenças finitas centrais de segunda ordem com pontos ao longo da placa. Isso gera uma malha com passo .

A equação diferencial é discretizada da seguinte forma:

Desse modo:

Essa equação gera um sistema linear tridiagonal, com as temperaturas desconhecidas nos nós internos.

3. Processamento: Código em Python com Gauss-Seidel

A seguir, o código Python implementando o método de Gauss-Seidel para resolver o sistema linear:

import numpy as np
import matplotlib.pyplot as plt

# Parâmetros
L = 1.0
N = 500
dx = L / (N + 1)
T0 = 300
T1 = 350
tol = 1e-6
max_iter = 10000

# Inicialização
T = np.linspace(T0, T1, N+2)  # incl. as bordas conhecidas
T_new = T.copy()

# Iteração de Gauss-Seidel
for _ in range(max_iter):
    T_old = T.copy()
    for i in range(1, N+1):
        T[i] = 0.5 * (T[i-1] + T[i+1])
    erro = np.linalg.norm(T - T_old, np.inf)
    if erro < tol:
        break

# Coordenadas espaciais
x = np.linspace(0, L, N+2)

import numpy as np
import matplotlib.pyplot as plt

# Parâmetros
L = 1.0
N = 500
dx = L / (N + 1)
T0 = 300
T1 = 350
tol = 1e-6
max_iter = 10000

# Inicialização
T = np.linspace(T0, T1, N+2)  # incl. as bordas conhecidas
T_new = T.copy()

# Iteração de Gauss-Seidel
for _ in range(max_iter):
    T_old = T.copy()
    for i in range(1, N+1):
        T[i] = 0.5 * (T[i-1] + T[i+1])
    erro = np.linalg.norm(T - T_old, np.inf)
    if erro < tol:
        break

# Coordenadas espaciais
x = np.linspace(0, L, N+2)

4. Pós-processamento: Visualização dos Resultados

Uma das grandes vantagens do Python é o pós-processamento imediato, seja usando Jupyter Notebook, Spyder ou outros ambientes. Veja o código de visualização:

# Solução analítica
T_analitico = T0 + (T1 - T0) * x

# Plot
plt.figure(figsize=(8, 4))
plt.plot(x, T, label='Numérica (Gauss-Seidel)', linewidth=2)
plt.plot(x, T_analitico, '--', label='Analítica', linewidth=2)
plt.xlabel('x [m]')
plt.ylabel('Temperatura [K]')
plt.title('Distribuição de Temperatura em Regime Estacionário')
plt.legend()
plt.grid(True)
plt.show()

# Solução analítica
T_analitico = T0 + (T1 - T0) * x

# Plot
plt.figure(figsize=(8, 4))
plt.plot(x, T, label='Numérica (Gauss-Seidel)', linewidth=2)
plt.plot(x, T_analitico, '--', label='Analítica', linewidth=2)
plt.xlabel('x [m]')
plt.ylabel('Temperatura [K]')
plt.title('Distribuição de Temperatura em Regime Estacionário')
plt.legend()
plt.grid(True)
plt.show()

Abaixo é ilustrado o gráfico da solução numérica e da solução analítica:

Em linguagens compiladas como Fortran ou C++, normalmente é necessário salvar os resultados em arquivos e usar outras ferramentas (ex: Tecplot, Paraview) para gerar os gráficos. Em Python, isso é feito na hora com poucos comandos.

Conclusão

Neste artigo, mostramos como o Python pode ser uma ferramenta poderosa para resolução de problemas de CFD. Mesmo sendo uma linguagem interpretada, suas bibliotecas otimizadas e facilidade de visualização tornam o desenvolvimento científico acessível e produtivo.

A equação diferencial foi resolvida numericamente via método de diferenças finitas com o solver de Gauss-Seidel. A solução numérica obteve excelente concordância com a solução analítica. Tudo isso foi feito com menos de 50 linhas de código, utilizando recursos totalmente gratuitos.

Python definitivamente é uma excelente porta de entrada para quem quer começar a explorar o mundo da simulação numérica na engenharia!