Em Python, simule uma caixa de partículas. As partículas serão liberadas todas de um mesmo ponto da caixa, imediatamente. Cada partícula possui uma velocidade aleatória de
. A caixa possui 1 m
. Ao bater na parede, cada partícula deve retornar com mesma velocidade, com direção simétrica ao ângulo com a parede. Simule a caixa pelos primeiros 10 segundos, obtendo a visualização das partículas na caixa.
Passo 1
O enunciado pede para simular em Python um conjunto de partículas liberadas de um mesmo ponto dentro de uma caixa quadrada de
m, cada uma com velocidade
m/s em direção aleatória, e com reflexão especular nas paredes. Vamos usar conceitos de cinemática discreta (método de Euler explícito), detectar colisões invertendo o componente da velocidade e, por fim, usar Matplotlib para animar a posição das partículas ao longo de
s.
Passo 2
Definimos as configurações básicas:
- número de partículas
, - posição inicial comum
, - velocidade escalar
m/s, - gerar direções aleatórias
e calcular .
Passo 3
Para a integração no tempo, escolhemos um passo
pequeno (por exemplo,
s). A cada iteração:
. Atualizamos posições:
- se
ou , fazemos e refletimos a posição de forma a mantê-la dentro dos limites, - análogo para
.
Para visualizar, usamos Matplotlib comFuncAnimation
. Criamos umscatter
e, a cada quadro, atualizamos os dados de posição do objeto de dispersão (\(set_offsets\)
). O tempo de animação és real, correspondente a quadros.
Passo 4
Segue o código completo em Python. Basta ter
numpy
e matplotlib
instalados.\(t_max =10.0\) # tempo total (s)
steps \(=\) int(\(t_max\) / dt)
# Posição inicial (meio da caixa)
x \(=\) np.full(N, L/\(2\))
y \(=\) np.full(N, L/\(2\))
# Direções iniciais aleatórias
theta \(=\) np.random.uniform(\(0\), \(2\)*np.pi, siz\(e=N\))
vx \(=\) v * np.cos(theta)
vy \(=\) v * np.sin(theta)
# Configuração da figura
fig, ax \(=\) plt.subplots(figsize\(=\)(\(5,5\)))
ax.\(set_xlim\)(\(0\), L)
ax.\(set_ylim\)(\(0\), L)
ax.\(set_aspect\)('equal')
scat \(=\) ax.scatter(x, y, s\(=20\), c\(=\)'blue')
def update(frame):
global x, y, vx, vy
# Atualiza posições
x \(+=\) vx * dt
y \(+=\) vy * dt
# Colisão nas paredes verticais
\(collided_left =\) x < \(0 collided_right =\) x > L
vx[\(collided_left\) | \(collided_right\)] *\(=\) -\(1\)
# Reflete posição para dentro da caixa
x[\(collided_left\)] \(=\) -x[\(collided_left\)]
x[\(collided_right\)] \(=2\)*L - x[\(collided_right\)]
# Colisão nas paredes horizontais
\(collided_bottom =\) y < \(0 collided_top =\) y > L
vy[\(collided_bottom\) | \(collided_top\)] *\(=\) -\(1\)
# Reflete posição para dentro da caixa
y[\(collided_bottom\)] \(=\) -y[\(collided_bottom\)]
y[\(collided_top\)] \(=2\)*L - y[\(collided_top\)]
# Atualiza o scatter plot
scat.\(set_offsets\)(np.\(column_stack\)([x, y]))
return scat,
ani \(=\) FuncAnimation(fig, update, frame\(s=s\)teps, interva\(l=d\)t*\(1000\), bli\(t=T\)rue)
plt.title("Simulação de partículas em caixa \(1\times 1\) m")
plt.show()
Resposta
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# Parâmetros da simulação
N \(=100\) # número de partículas
L \(=1.0\) # tamanho da caixa (\(1\) m x \(1\) m)
v \(=0.3\) # velocidade escalar (m/s)
dt \(=0.01\)