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 0,3 \mathrm{~m} / \mathrm{s}. A caixa possui 1 m \times 1 \mathrm{~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 1\times1 m, cada uma com velocidade 0,3 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 10 s.

Passo 2

Definimos as configurações básicas:
  • número de partículas N,
  • posição inicial comum (x_0,y_0),
  • velocidade escalar v=0,3 m/s,
  • gerar direções aleatórias \theta_i\sim U(0,2\pi) e calcular (v_{x,i},v_{y,i})=(v\cos\theta_i,\,v\sin\theta_i).

Passo 3

Para a integração no tempo, escolhemos um passo \Delta t pequeno (por exemplo, 0,01 s). A cada iteração:
1. Atualizamos posições:
x_i \leftarrow x_i + v_{x,i}\,\Delta t,\quad y_i \leftarrow y_i + v_{y,i}\,\Delta t.
2. Detectamos colisões com as paredes
  • se x_i<0 ou x_i>1, fazemos v_{x,i}\leftarrow -v_{x,i} e refletimos a posição de forma a mantê-la dentro dos limites,
  • análogo para y.
    Para visualizar, usamos Matplotlib com FuncAnimation. Criamos um scatter e, a cada quadro, atualizamos os dados de posição do objeto de dispersão (\(set_offsets\)). O tempo de animação é 10 s real, correspondente a 10/\Delta t 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\)

Exercícios relacionados