Considere uma corda elástica de comprimento L cujas extremidades estão fixas. A corda é posta em movimento sem velocidade inicial a partir de uma posição inicial u(x, 0)=f(x). Em cada um dos Problemas 1 a 4, execute os seguintes passos. Deixe L=10 e a=1 nas partes (b) a (d).
(d) Construa uma animação da solução no tempo por pelo menos um período.
  1. f(x)=lr2 x / L, & 0 <= x <= L / 2, 2(L-x) / L, & L / 2

Passo 1

Nesse problema temos uma corda elástica de comprimento L=10 com extremidades fixas, sujeita à equação da onda utt=a^2uxx com a=1, sem velocidade inicial e deslocamento inicial u(x,0)=f(x), onde
$$f(x)=\begin{cases}\frac{2x}{L}, &0\le x\le \frac L2,\[6pt]\frac{2(L-x)}{L}, &\frac L2<x\le L.
\end{cases}$$
Precisamos construir uma animação da solução f(x)=2xL, &0<= x<= L2,[6pt]2(L-x)L, & L2 variando no tempo por pelo menos um período completo.

Passo 2

A solução por séries de Fourier (modo seno) é dada por
u(x,t)=sumn=1^inftyAncosl(tfracnpi aLtr)sinl(tfracnpiLxr),
com coeficientes
An=2Lintegral0^Lf(x)sinl(tfracnpiLxr),dx
Como f(x) é dado por partes, ou avaliamos An analiticamente ou fazemos numericamente no código.

Passo 3

O período fundamental da corda é
T=2La=2cdot101=20
Para animar precisamos variar t de zero até pelo menos T=20 e reconstruir u(x,t) em cada instante.

Passo 4

A seguir está um exemplo de código em Python usando NumPy e Matplotlib para calcular os An numericamente, truncar a série em N termos e gerar a animação de u(x,t) para um período:

Passo 5

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Parâmetros
def f(x, L=10):
    return np.where(x<=L/2, 2*x/L, 2*(L-x)/L)

L = 10.0
a = 1.0
N = 50            # número de modos
x = np.linspace(0, L, 400)

# Calcula coeficientes A_n numericamente
def compute_An(n):
    integrand = f(x)*np.sin(n*np.pi*x/L)
    return (2/L)*np.trapz(integrand, x)

A = np.array([compute_An(n) for n in range(1, N+1)])

# Função u(x,t)
def u_xt(x, t):
    n = np.arange(1, N+1)
    terms = A * np.cos(n*np.pi*a*t/L)[:,None] * np.sin(n*np.pi*x/L)[None,:]
    return np.sum(terms, axis=0)

# Configura figura
fig, ax = plt.subplots()
line, = ax.plot(x, u_xt(x, 0))
ax.set_xlim(0, L)
ax.set_ylim(-1.1, 1.1)
ax.set_xlabel('x')
ax.set_ylabel('u(x,t)')
ax.set_title('Onda na corda')

# Função de atualização para animação
def animate(frame):
    t = frame*0.1          # passo de tempo
    y = u_xt(x, t)
    line.set_ydata(y)
    ax.set_title(f't = {t:.1f}')
    return line,

# Cria animação para t de 0 a 20 (período)
frames = int(20/0.1)
anims = animation.FuncAnimation(fig, animate, frames=frames, interval=50, blit=True)

# Salvar como mp4 ou mostrar
# anims.save('onda_corda.mp4', writer='ffmpeg')
plt.show()

Resposta

O código acima gera uma animação de u(x,t) variando de t=0 a t=20, mostrando pelo menos um período completo da vibração da corda.

Exercícios relacionados