Escreva um programa computacional que resolva a integral de convolução definida na questão anterior e simule a resposta no tempo do sistema para valores da razão t_{d} / T no intervalo 0 \leqslant t_{d} / T \leqslant 6. Para cada resposta, obtenha o máximo valor do fator de amplificação dinâmica do sistema na condição de movimento livre, bem como o máximo valor do fator de amplificação dinâmica do sistema na condição de movimento forçado. Obtenha o máximo valor do fator de amplificação dinâmica considerando simultaneamente os regimes livre e forçado (Shock Spectrum). Apresente os resultados graficamente em função da razão t_{d} / T.

Passo 1

O enunciado pede para escrever um programa que, para um sistema SDOF não amortecido sujeito a um pulso de aceleração de duração t_{d}, calcule a resposta no tempo via integral de convolução, varrendo a razão \,t_{d}/T\in[0,6]. Para cada valor de t_{d}/T devemos extrair
  1. o máximo do fator de amplificação dinâmica em regime forçado 0\le t\le t_{d},
  2. o máximo do fator de amplificação dinâmica em regime livre t>t_{d},
  3. o máximo combinado (Shock Spectrum).
    Em seguida mostramos graficamente esses máximos em função de t_{d}/T. Vamos usar Python com NumPy e Matplotlib.

Passo 2

Definimos parâmetros do sistema e da simulação:
  • escolhemos massa m=1, período natural T=1 s, logo \omega_{n}=2\pi/T;
  • a aceleração do pulso tem amplitude unitária, a_{0}=1;
  • o impulso resposta \,h(t) de um SDOF não amortecido vale
h(t)=\frac{\sin(\omega_{n}t)}{m\,\omega_{n}}\,,
válida para t\ge0;
  • discretizamos o tempo de t=0 até t_{\max}=20\,T com passo \Delta t=T/200.

Passo 3

Para cada razão \displaystyle R=\frac{t_{d}}{T} no intervalo [0,6]:
  1. calculamos t_{d}=R\,T;
  2. montamos o vetor de entrada de aceleração
u(t_{i})=\begin{cases} 1, & t_{i}\le t_{d},\\\\ 0, & t_{i}>t_{d}, \end{cases}
  1. avaliamos a convolução discreta
x(t)=\int_{0}^{t}h(t-\tau)\,u(\tau)\,d\tau
via numpy.convolve(u,h)*Δt e truncamos ao tamanho do vetor de tempo.

Passo 4

Com x(t) em mãos, definimos:
  • deslocamento estático para a_{0}=1:
\delta_{\mathrm{est}}=\frac{a_{0}}{\omega_{n}^{2}}\,;
  • em regime forçado tomamos todos os instantes t_{i}\le t_{d} e calculamos
A_{\mathrm{forçado}} =\max_{t_{i}\le t_{d}}\frac{|x(t_{i})|}{\delta_{\mathrm{est}}},ç
  • em regime livre tomamos t_{i}>t_{d} e calculamos
A_{\mathrm{livre}} =\max_{t_{i}>t_{d}}\frac{|x(t_{i})|}{\delta_{\mathrm{est}}},
  • o Shock Spectrum é
A_{\mathrm{choque}} =\max\bigl(A_{\mathrm{forçado}},\,A_{\mathrm{livre}}\bigr).ç

Passo 5

Repetimos o passo anterior para uma malha de N razões R uniformemente espaçadas em [0,6]. Armazenamos arrays com \{A_{\mathrm{forçado}}(R),\,A_{\mathrm{livre}}(R),\,A_{\mathrm{choque}}(R)\}ç.

Passo 6

Por fim, plotamos em um mesmo gráfico o fator de amplificação dinâmica máximo nas três condições versus R=t_{d}/T. Usamos escala linear no eixo x e logarítmica ou linear no eixo y.

Resposta

def h(t):
return np.sin( omega_nt)/(m omega_n)

Discretização do tempo

dt = T/200
t_max =20*T
t = np.arange(0, t_ma x+dt, dt)

Malha de razões td/T

R_vals = np.linspace(0, 6, 301) # 301 pontos em [0,6]
A_forcado = np. zeros_like( R_vals)
A_livre = np. zeros_like( R_vals)
A_choque = np. zeros_like( R_vals)

Pre-computar h(t) para convolução

h_vec = h(t)

deslocamento estático para a 0=1 delta_est = a0/( omega_n**2)

for i, R in enumerate( R_vals):
td = R * T

vetor de entrada u(t)

u = np.where(t <= td, a0, 0.0)

convolução discreta aproximando a integral

x_conv = np.convolve(u, h_vec, mode=‘full’) * dt
x = x_conv[:len(t)] # truncar ao tamanho de t

máscaras regimes

forced_mask = (t <= td)
free_mask = (t > td)

fatores de amplificação

A_for = np.max(np.abs(x[ forced_mask])) / delta_est A_free= np.max(np.abs(x[ free_mask])) / delta_est A_forcado[i] = A_for A_livre[i] = A_free A_choque[i] = max( A_for, A_free)

Plot dos resultados

plt.figure(figsize=(8,5))
plt.plot( R_vals, A_forcado, label=‘Forçado’)
plt.plot( R_vals, A_livre, label=‘Livre’)
plt.plot( R_vals, A_choque, label=‘Choque (máximo)’)
plt.xlabel(r’ t_{d}/T’)
plt.ylabel(‘Fator de amplificação dinâmica’)
plt.legend()
plt.grid(True)
plt.title('Shock Spectrum vs t_{d}/T')
plt.show()
Esse script varre a razão \(t_{d}/T\in[0,6]\), calcula o deslocamento por convolução, extrai os máximos nos regimes forçado e livre, obtém o Shock Spectrum e apresenta o gráfico solicitado.

Exercícios relacionados