Introdução
O pêndulo duplo é um problema clássico em física e matemática. Ele envolve dois pêndulos ligados um ao outro, e o movimento do segundo pêndulo é afetado pelo movimento do primeiro pêndulo. Neste laboratório, usaremos Python e Matplotlib para simular o movimento de um pêndulo duplo.
Dicas para a VM (Virtual Machine)
Após a inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook e acessar o Jupyter Notebook para praticar.
Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.
Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos o problema prontamente para você.
Importar as Bibliotecas Necessárias
Começaremos importando as bibliotecas necessárias para nossa simulação.
from collections import deque
import matplotlib.pyplot as plt
import numpy as np
from numpy import cos, sin
import matplotlib.animation as animation
Configurar Parâmetros
Em seguida, definiremos os parâmetros para nossa simulação. Esses parâmetros incluem a aceleração devido à gravidade, o comprimento e a massa de cada pêndulo e o intervalo de tempo para a simulação.
G = 9.8 ## aceleração devido à gravidade, em m/s^2
L1 = 1.0 ## comprimento do pêndulo 1 em m
L2 = 1.0 ## comprimento do pêndulo 2 em m
L = L1 + L2 ## comprimento máximo do pêndulo combinado
M1 = 1.0 ## massa do pêndulo 1 em kg
M2 = 1.0 ## massa do pêndulo 2 em kg
t_stop = 2.5 ## quantos segundos simular
history_len = 500 ## quantos pontos de trajetória exibir
Definir a Função de Derivadas
Definiremos uma função que calcula as derivadas do sistema em um determinado momento. Esta função recebe o estado atual do sistema (os ângulos e as velocidades angulares de cada pêndulo) e retorna as derivadas desses valores.
def derivs(t, state):
dydx = np.zeros_like(state)
dydx[0] = state[1]
delta = state[2] - state[0]
den1 = (M1+M2) * L1 - M2 * L1 * cos(delta) * cos(delta)
dydx[1] = ((M2 * L1 * state[1] * state[1] * sin(delta) * cos(delta)
+ M2 * G * sin(state[2]) * cos(delta)
+ M2 * L2 * state[3] * state[3] * sin(delta)
- (M1+M2) * G * sin(state[0]))
/ den1)
dydx[2] = state[3]
den2 = (L2/L1) * den1
dydx[3] = ((- M2 * L2 * state[3] * state[3] * sin(delta) * cos(delta)
+ (M1+M2) * G * sin(state[0]) * cos(delta)
- (M1+M2) * L1 * state[1] * state[1] * sin(delta)
- (M1+M2) * G * sin(state[2]))
/ den2)
return dydx
Configurar as Condições Iniciais e Integrar a EDO
Agora, configuraremos as condições iniciais para nossa simulação. Definiremos os ângulos e as velocidades angulares iniciais de cada pêndulo, bem como o intervalo de tempo para a simulação. Em seguida, integraremos a EDO (Equação Diferencial Ordinária - ODE) usando o método de Euler para obter a posição e a velocidade de cada pêndulo em cada passo de tempo.
## criar um array de tempo de 0..t_stop amostrado em passos de 0.02 segundos
dt = 0.01
t = np.arange(0, t_stop, dt)
## th1 e th2 são os ângulos iniciais (graus)
## w10 e w20 são as velocidades angulares iniciais (graus por segundo)
th1 = 120.0
w1 = 0.0
th2 = -10.0
w2 = 0.0
## estado inicial
state = np.radians([th1, w1, th2, w2])
## integrar a EDO usando o método de Euler
y = np.empty((len(t), 4))
y[0] = state
for i in range(1, len(t)):
y[i] = y[i - 1] + derivs(t[i - 1], y[i - 1]) * dt
Calcular a Posição de Cada Pêndulo
Agora, usaremos a posição e a velocidade de cada pêndulo em cada passo de tempo para calcular as coordenadas x e y de cada pêndulo.
x1 = L1*sin(y[:, 0])
y1 = -L1*cos(y[:, 0])
x2 = L2*sin(y[:, 2]) + x1
y2 = -L2*cos(y[:, 2]) + y1
Configurar o Gráfico
Agora, configuraremos o gráfico para nossa simulação. Criaremos uma figura com um limite em x e y igual ao comprimento máximo do pêndulo, definiremos a proporção (aspect ratio) para ser igual e adicionaremos uma grade.
fig = plt.figure(figsize=(5, 4))
ax = fig.add_subplot(autoscale_on=False, xlim=(-L, L), ylim=(-L, 1.))
ax.set_aspect('equal')
ax.grid()
Definir a Função de Animação
Definiremos uma função que animará o movimento do pêndulo duplo. Esta função receberá o passo de tempo atual e o usará para atualizar a posição de cada pêndulo. Ela também atualizará a trajetória do segundo pêndulo.
line, = ax.plot([], [], 'o-', lw=2)
trace, = ax.plot([], [], '.-', lw=1, ms=2)
time_template = 'time = %.1fs'
time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)
history_x, history_y = deque(maxlen=history_len), deque(maxlen=history_len)
def animate(i):
thisx = [0, x1[i], x2[i]]
thisy = [0, y1[i], y2[i]]
if i == 0:
history_x.clear()
history_y.clear()
history_x.appendleft(thisx[2])
history_y.appendleft(thisy[2])
line.set_data(thisx, thisy)
trace.set_data(history_x, history_y)
time_text.set_text(time_template % (i*dt))
return line, trace, time_text
Criar a Animação
Agora, criaremos a animação usando a função FuncAnimation do Matplotlib.
ani = animation.FuncAnimation(
fig, animate, len(y), interval=dt*1000, blit=True)
plt.show()
Resumo
Neste laboratório, usamos Python e Matplotlib para simular o movimento de um pêndulo duplo. Definimos os parâmetros para nossa simulação, definimos uma função para calcular as derivadas do sistema, integramos a EDO (Equação Diferencial Ordinária - ODE) usando o método de Euler, calculamos a posição de cada pêndulo em cada passo de tempo e criamos uma animação do movimento do pêndulo duplo.