a) Determine a solução de vibração livre de uma membrana retangular de lados a e b ao longo dos eixos x e y utilizando o método de separação de variáveis.
b) Atribua valores numéricos e crie no Colab um mapa tridimensional sobre a vibração dessa membrana retangular. Interprete os resultados.
Passo 1
O enunciado pede duas coisas, então vamos enumerar claramente o que é dado e o que precisamos encontrar:
Pergunta (a): Determinar a solução de vibração livre de uma membrana retangular de lados a e b (ao longo dos eixos x e y) usando o método de separação de variáveis.
Informação dada: a membrana é retangular com dimensões a (no eixo x) e b (no eixo y).
Informação implícita (questão padrão de vibração livre): as bordas da membrana estão presas (condições de contorno de Dirichlet homogêneas), ou seja, a deflexão na fronteira é zero para todo t: \,u(0,y,t)=u(a,y,t)=0 e \,u(x,0,t)=u(x,b,t)=0.
O que pedir: obter as funções de modo normal (autofunções espaciais) e as frequências próprias (autovalores temporais), e a expressão geral da vibração livre (série em modos).
Pergunta (b): Atribuir valores numéricos e criar no Colab um mapa tridimensional sobre a vibração dessa membrana retangular, e interpretar os resultados.
Informação dada: usar valores numéricos (escolheremos valores razoáveis) e montar um gráfico 3D (superfície) que mostre a forma da vibração para modos ou combinações de modos selecionadas.
O que pedir: fornecer código pronto para Colab que plote a superfície u(x,y,t) para valores numéricos escolhidos, e interpretar (explicar) o que os padrões mostram (linhas nodais, influência dos modos, variação temporal e efeito de a,b,c).
A partir daqui eu vou fazer a derivação por separação de variáveis (passo a passo, sem pular etapas), mostrar como obter as formas modais e as frequências, ensinar como calcular os coeficientes a partir de condições iniciais, e depois apresentar o código Colab com valores numéricos e interpretar o resultado.
Passo 2
Escrever a equação diferencial parcial que descreve a vibração de uma membrana fina e as condições de contorno.
A equação da onda 2D para a deflexão u(x,y,t) de uma membrana tensa é
u_{tt} é a segunda derivada temporal de u (aceleração vertical),
u_{xx} e u_{yy} são as segundas derivadas espaciais (curvaturas),
c é a velocidade de propagação de ondas na membrana, dada por c=\sqrt{T/\rho} (tensão por unidade de massa linear) — aqui tratamos c como constante conhecida.
Condições de contorno (bordas presas, Dirichlet homogêneas):
u(0,y,t)=0,\quad u(a,y,t)=0,\quad u(x,0,t)=0,\quad u(x,b,t)=0\quad\text{para todo }t.
Condições iniciais (para determinação dos coeficientes da série): normalmente são
u(x,y,0)=f(x,y),\qquad u_{t}(x,y,0)=g(x,y),
onde f é a deflexão inicial e g a velocidade inicial. O enunciado não deu f e g, então vamos obter a solução modal geral (série) em termos dessas funções; depois, no item (b), usarei exemplos numéricos concretos.
Passo 3
Assumir solução separável e substituir na equação — ideia e primeiros passos.
Tentamos uma solução separável do tipo
u(x,y,t)=X(x)\,Y(y)\,T(t),
onde X depende só de x, Y só de y e T só de t.
Substituindo na equação u_{tt}=c^2(u_{xx}+u_{yy}):
Calcule as derivadas:
u_{tt}=X(x)Y(y)T''(t),
u_{xx}=X''(x)Y(y)T(t),
u_{yy}=X(x)Y''(y)T(t).
Substituindo:
X Y T'' = c^2\bigl(X'' Y T + X Y'' T\bigr).
Dividindo ambos os lados por c^2 X Y T (assumindo que nenhuma função é identicamente zero):
Observação chave do método: o lado esquerdo depende apenas de t e o lado direito apenas de x e y. Para que isso seja verdade para todos x,y,t, ambos os lados devem ser iguais a uma constante. Chamamos essa constante de -\lambda (o sinal negativo será conveniente para obter soluções oscilatórias no tempo).
O lado esquerdo depende só de x e o direito só de y; portanto cada lado deve ser igual a uma constante. Introduzimos uma constante positiva \alpha tal que
com \alpha+\beta=\lambda. (Escolhemos sinais negativos para obter soluções senoidais compatíveis com as condições de contorno.)
Então obtemos dois problemas ordinários:
X''(x) + \alpha X(x) = 0,\qquad X(0)=0,\; X(a)=0,
Y''(y) + \beta Y(y) = 0,\qquad Y(0)=0,\; Y(b)=0.
Esses são problemas Sturm–Liouville clássicos na forma de autovalor com condições de Dirichlet.
Passo 5
Resolver os problemas em X e Y (autovalores e autofunções espaciais).
Resolver X'' + \alpha X = 0 com X(0)=X(a)=0.
Se \alpha=0 ou \alpha<0 não temos soluções não-triviais que satisfaçam ambas as condições (apenas a solução trivial X\equiv0), portanto \alpha>0. Escrevemos \alpha = \left(\dfrac{m\pi}{a}\right)^2 com m\in\mathbb{N}. Assim as soluções não-triviais são
Interpretação: cada par de inteiros positivos (m,n) define um modo normal que vibra com frequência \omega_{mn}. Modos com índices maiores têm mais “meias-ondas” no interior da membrana e geralmente frequências maiores.
Passo 7
Escrever a solução modal e a solução geral como série (expansão em autofunções).
A solução geral (vibração livre com condições iniciais genéricas f,g\)) é a soma (série dupla) sobre todos os modos:
\[u(x,y,t) = \sum_{m=1}^{\infty}\sum_{n=1}^{\infty} \Bigl(A_{mn}\cos(\omega_{mn} t) + B_{mn}\sin(\omega_{mn} t)\Bigr) \sin\!\left(\dfrac{m\pi x}{a}\right)\sin\!\left(\dfrac{n\pi y}{b}\right).
Agora, como determinar A_{mn} e B_{mn} a partir das condições iniciais? Usamos ortogonalidade das funções seno:
Para B_{mn} usamos u_t(x,y,0)=g(x,y). Calculando u_t a t=0 dá u_t(x,y,0)=\sum \omega_{mn}(-A_{mn}\sin0 + B_{mn}\cos0)\sin\sin = \sum \omega_{mn} B_{mn} \sin\sin. Assim
Observação prática para prova: use sempre a ortogonalidade dos senos, lembre que o fator de normalização em cada direção é a/2 e b/2, por isso aparece 4/(ab) quando combinamos as duas.]
Passo 8
Resumo prático das fórmulas finais (para decorar e usar em prova).
Isto responde (a): derivamos as autofunções espaciais, as frequências e a forma geral da série modal.
Passo 9
Parte (b): escolher valores numéricos, explicar escolha e apresentar código Colab para plot 3D de u(x,y,t).
Escolhas numéricas simples e pedagógicas (podem ser alteradas no Colab): a=1,0 (m), b=0,7 (m), c=1,0 (unidade arbitrária — pode representar \sqrt{T/\rho}). Vou mostrar a superposição de dois modos para um resultado visualmente interessante:
modo 1: (m_1,n_1)=(1,1) amplitude A_1=1,0,
modo 2: (m_2,n_2)=(2,1) amplitude A_2=0,5,
consideramos velocidade inicial nula (g\equiv0) para simplicidade, então usaremos somente coeficientes associados ao deslocamento inicial (vamos escolher que f corresponde exatamente a essa combinação de modos, o que simplifica e demonstra os padrões).
Código Python para Colab (executar em uma célula). O código plota uma superfície 3D em um dado instante t. No Colab você pode alterar t manualmente e reexecutar a célula para ver diferentes frames. O código usa numpy e matplotlib; são bibliotecas padrão em Colab.
# Código para Colab: plot 3D da membrana (modo superposto)import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D # necessário para a projeção 3d# parâmetros (mude aqui se quiser)
a = 1.0# comprimento em x (m)
b = 0.7# comprimento em y (m)
c = 1.0# velocidade de onda (unidade arbitrária)# modos e amplitudes escolhidos
m1, n1, A1 = 1, 1, 1.0
m2, n2, A2 = 2, 1, 0.5# calcular frequências angulares
omega11 = c * np.sqrt((m1*np.pi/a)**2 + (n1*np.pi/b)**2)
omega21 = c * np.sqrt((m2*np.pi/a)**2 + (n2*np.pi/b)**2)
# malha espacial
nx, ny = 100, 80
x = np.linspace(0, a, nx)
y = np.linspace(0, b, ny)
X, Y = np.meshgrid(x, y)
# instante de tempo para visualizar
t = 0.0# mude para ver diferentes instantes, ex: t = 0.1, 0.5, 1.0# função de vibração: superposição de dois modos (velocidade inicial nula)
U = (A1 * np.cos(omega11 * t) * np.sin(m1 * np.pi * X / a) * np.sin(n1 * np.pi * Y / b)
+ A2 * np.cos(omega21 * t) * np.sin(m2 * np.pi * X / a) * np.sin(n2 * np.pi * Y / b))
# plot 3D
fig = plt.figure(figsize=(9,6))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, U, cmap='viridis', edgecolor='none', rcount=100, ccount=100)
ax.set_xlabel('x (m)')
ax.set_ylabel('y (m)')
ax.set_zlabel('u(x,y,t)')
ax.set_title(f'Membrana retangular: superposição modos (1,1) e (2,1), t={t:.2f}')
fig.colorbar(surf, shrink=0.6, aspect=15)
plt.show()
Observações sobre o código:
Para ver a vibração variar no tempo, altere o valor de t e reexecute a célula. Se quiser uma animação automática no Colab, podemos usar matplotlib.animation e salvar como GIF ou mostrar HTML, mas isso requer passos extras; a opção acima é a mais direta e confiável.
Para aumentar resolução, aumente nx, ny. Para mais modos, some termos adicionais análogos ao A1 e A2.
Passo 10
Interpretação dos resultados do gráfico (o que você deve observar ao executar o Colab).
Linhas nodais: onde a função seno em x ou y anula a solução, aparecem linhas (ou curvas) onde u=0 para todos os instantes (t variando apenas muda sinal/amplitude mas zero permanece). Por exemplo:
para o modo (m,n), existem m-1 linhas nodais internas paralelas ao eixo y (origem das zeros de \sin(m\pi x/a)) e n-1 linhas nodais internas paralelas ao eixo x.
Número de “campânulas” (picos e vales): o modo (1,1) tem um padrão com um pico no centro (sem nodal interno), já (2,1) terá uma divisão em x com uma linha nodal vertical no meio. A superposição mostra combinação desses padrões: dependendo do tempo e das amplitudes, algumas regiões se reforçam (soma construtiva) e outras se cancelam (soma destrutiva).
Frequências: \omega_{mn} cresce quando m ou n aumentam, ou quando a e b diminuem (mais “aperto” => mais alta frequência), ou quando c aumenta. No gráfico estático você não vê \omega diretamente, mas ao variar t nota que modos de maior (m,n) mudam de sinal mais rapidamente (oscilem mais rápido).
Efeito das amplitudes: se A_2 for pequeno em relação a A_1, o padrão dominante será do modo (1,1) com pequenas perturbações; se forem comparáveis, o padrão pode ficar mais complexo, aparição de nós móveis e regiões de interferência.
Para obter coeficientes reais a partir de um deslocamento inicial f(x,y) qualquer, projetamos f nas autofunções via integrais (fórmulas do passo 7). No Colab você pode definir f e computar numericamente as integrais duplas para obter A_{mn}.
Resposta
(a) A solução geral da vibração livre da membrana retangular com bordas presas é
(b) Exemplo numérico e código Colab: com a=1,0, b=0,7, c=1,0, escolhendo a superposição dos modos (1,1) (amplitude 1,0) e (2,1) (amplitude 0,5) e velocidade inicial nula, a função plotada é
com o código Python fornecido no Passo 9 para gerar o mapa 3D; a interpretação está no Passo 10 (linhas nodais, interferência entre modos, influência de a,b,c e das amplitudes).