Um estudo sobre o modelo Físico do Salto de Bungee Jumping

Prof. Doherty Andrade - www.metodosnumericos.com.br

Resumo

Este trabalho apresenta um modelo matemático para descrever a trajetória e velocidade de um saltador de Bungee Jumping, utilizando o método numérico de Runge Kutta de 4ª ordem para resolver as equações diferenciais do movimento. O trabalho aborda tanto a fase de queda livre quanto o movimento restringido pela corda elástica, considerando efeitos de amortecimento viscoso e forças aerodinâmicas.

Figura 1: Praticando Bungee Jumping.

Hipóteses e Modelo Matemático

Algumas hipóteses simplificadoras foram adotadas. Por exemplo, o saltador percorrerá a trajetoria apenas na vertical, desprezando o delocamento lateral provocado por ventos. Obteremos assim um modelo unidimensional.

Hipóteses Principais

Equações do Movimento

Queda Livre (antes da corda esticar)

\[ f_1\left(\frac{dy}{dt}\right) = \frac{d^2y}{dt^2} = \frac{1}{m_c + m_c \frac{\rho_f}{2\rho_c}} \left[ \left(-m_c + m_c \frac{\rho_f}{\rho_c}\right)g + \frac{1}{2} \frac{dy}{dt} \left|\frac{dy}{dt}\right| \frac{m_c h_c}{3600} \rho_f C_d \right] \]

Onde:

Observamos que a equação depende apenas da velocidade \(\frac{dy}{dt}\) e que descreve comportamento do corpo em queda livre.

Movimento Restringido (após a corda esticar)

O segundo momento terá início quando for aplicada uma tensão sobre a corda.
\[ f_2\left(\frac{dy}{dt}, y\right) = \frac{d^2y}{dt^2} = f_1 + \frac{1}{m_c} \left[c \frac{dy}{dt} + k(y + L)\right] \]

Com termos adicionais:

Afim de utilizarmos o método de Runge-Kutta para sistemas vamos introduzir a terceira função: \[f_3= \frac{dy}{dt}.\]

Método Numérico: Runge Kutta 4ª Ordem

Teoria do Método RK4 para Sistemas

+

Para Queda Livre (2 variáveis)

\[ v_{n+1} = v_n + \frac{h}{6}(k_1 + 2k_2 + 2k_3 + k_4) \] \[ t_{n+1} = t_n + h \]

Onde as constantes são:

\[ \begin{aligned} k_1 &= f_1(t_n, v_n) \\ k_2 &= f_1(t_n + \frac{h}{2}, v_n + \frac{h}{2}k_1) \\ k_3 &= f_1(t_n + \frac{h}{2}, v_n + \frac{h}{2}k_2) \\ k_4 &= f_1(t_n + h, v_n + hk_3) \end{aligned} \]

Para Movimento Restringido (3 variáveis)

\[ y_{n+1} = y_n + \frac{h}{6}(k_1 + 2k_2 + 2k_3 + k_4) \] \[ v_{n+1} = v_n + \frac{h}{6}(l_1 + 2l_2 + 2l_3 + l_4) \] \[ t_{n+1} = t_n + h \]

Com constantes:

\[ \begin{aligned} k_1 &= f_3(v_n) \\ l_1 &= f_2(y_n, v_n) \\ k_2 &= f_3(v_n + \frac{h}{2}l_1) \\ l_2 &= f_2(y_n + \frac{h}{2}k_1, v_n + \frac{h}{2}l_1) \\ k_3 &= f_3(v_n + \frac{h}{2}l_2) \\ l_3 &= f_2(y_n + \frac{h}{2}k_2, v_n + \frac{h}{2}l_2) \\ k_4 &= f_3(v_n + hl_3) \\ l_4 &= f_2(y_n + hk_3, v_n + hl_3) \end{aligned} \]

Transformação de EDOs de Segunda Ordem para Sistemas

O movimento no bungee jumping é descrito por equações diferenciais de segunda ordem, que podem ser transformadas em sistemas de primeira ordem para aplicação do método de Runge-Kutta.

1. Queda Livre (y ≤ L)

EDO original (segunda ordem):

\[ \frac{d^2y}{dt^2} = g \]

Sistema equivalente (duas EDOs de primeira ordem):

\[ \begin{cases} \displaystyle \frac{dy}{dt} = v \\ \displaystyle \frac{dv}{dt} = g \end{cases} \]
2. Corda Esticada (y > L)

EDO original (segunda ordem):

\[ \frac{d^2y}{dt^2} = g - \frac{k}{m}(y - L) - \frac{c}{m}v \]

Sistema equivalente:

\[ \begin{cases} \displaystyle \frac{dy}{dt} = v \\ \displaystyle \frac{dv}{dt} = g - \frac{k}{m}(y - L) - \frac{c}{m}v \end{cases} \]

Implementação Numérica (com simplificações)

Python
MATLAB
Maple
Python 
# Modelo de Bungee Jumping - Solução Numérica em Python
import numpy as np
import matplotlib.pyplot as plt

# Parâmetros do modelo
mc = 70       # Massa do saltador (kg)
L = 50        # Comprimento da corda (m)
k = 100       # Rigidez da corda (N/m) 
c = 15        # Coeficiente de amortecimento (Ns/m)
g = 9.81      # Gravidade (m/s²)

# Condições iniciais
y0 = 0        # Posição inicial (m)
v0 = 0        # Velocidade inicial (m/s)
t0, t_total = 0, 60  # Tempo inicial e total (s)
h = 0.1       # Passo de tempo (s)

# Pré-alocação de arrays
t = np.arange(t0, t_total + h, h)
y = np.zeros_like(t)
v = np.zeros_like(t)
y[0], v[0] = y0, v0

# Funções das equações diferenciais
def f1(v):
    return g - 0.1*v*abs(v)  # Queda livre com arrasto

def f2(y, v):
    return g - (k/mc)*max(y-L,0) - (c/mc)*v  # Corda tensionada

# Implementação do Runge-Kutta 4ª ordem
for i in range(len(t) - 1):
    if y[i] <= L:  # Queda livre
        k1 = f1(v[i])
        k2 = f1(v[i] + 0.5*h*k1)
        k3 = f1(v[i] + 0.5*h*k2)
        k4 = f1(v[i] + h*k3)
        v[i+1] = v[i] + (h/6)*(k1 + 2*k2 + 2*k3 + k4)
        y[i+1] = y[i] + h*v[i]
    else:  # Movimento restringido
        k1_v = f2(y[i], v[i])
        k1_y = v[i]
        
        k2_v = f2(y[i] + 0.5*h*k1_y, v[i] + 0.5*h*k1_v)
        k2_y = v[i] + 0.5*h*k1_v
        
        k3_v = f2(y[i] + 0.5*h*k2_y, v[i] + 0.5*h*k2_v)
        k3_y = v[i] + 0.5*h*k2_v
        
        k4_v = f2(y[i] + h*k3_y, v[i] + h*k3_v)
        k4_y = v[i] + h*k3_v
        
        y[i+1] = y[i] + (h/6)*(k1_y + 2*k2_y + 2*k3_y + k4_y)
        v[i+1] = v[i] + (h/6)*(k1_v + 2*k2_v + 2*k3_v + k4_v)

# Cálculos adicionais
v_terminal = np.sqrt(2*mc*g/(1.225*0.5*0.04))  # Velocidade terminal teórica
print(f"Velocidade terminal teórica: {v_terminal:.2f} m/s")

# Gráficos
plt.figure(figsize=(12, 8))
plt.subplot(2, 1, 1)
plt.plot(t, y, 'b-', linewidth=2, label='Posição')
plt.axhline(y=L, color='r', linestyle='--', label='Comprimento da corda')
plt.ylabel('Altura (m)')
plt.title('Modelo de Bungee Jumping')
plt.legend()
plt.grid(True)

plt.subplot(2, 1, 2)
plt.plot(t, v, 'm-', linewidth=2, label='Velocidade')
plt.xlabel('Tempo (s)')
plt.ylabel('Velocidade (m/s)')
plt.legend()
plt.grid(True)

plt.tight_layout()
plt.show()
MATLAB 
%% Modelo Físico de Bungee Jumping - Solução Numérica com Runge-Kutta 4ª Ordem

clc; clear; close all;

%% Parâmetros 
mc = 70;        % Massa do saltador (kg)
L = 40;         % Comprimento da corda (m)
k = 80;         % Rigidez (N/m)
c = 10;         % Amortecimento (Ns/m)
g = 9.81;       % Gravidade

% Condições Iniciais
y0 = 0; v0 = 0; t0 = 0; t_total = 60; h = 0.05;

%% Equações
f1 = @(v) g - 0.1*v*abs(v);  % Queda livre com arrasto
f2 = @(y, v) g - (k/mc)*max(y-L,0) - (c/mc)*v; % Corda tensionada

%% Simulação RK4
t = t0:h:t_total;
N = length(t);
y = zeros(1,N); v = zeros(1,N);
y(1) = y0; v(1) = v0;

for i = 1:N-1
    if y(i) <= L
        % Queda livre
        k1 = f1(v(i));
        k2 = f1(v(i) + 0.5*h*k1);
        k3 = f1(v(i) + 0.5*h*k2);
        k4 = f1(v(i) + h*k3);
        v(i+1) = v(i) + (h/6)*(k1 + 2*k2 + 2*k3 + k4);
        y(i+1) = y(i) + h*v(i);
    else
        % Corda tensionada
        k1_v = f2(y(i), v(i));
        k1_y = v(i);
        k2_v = f2(y(i)+0.5*h*k1_y, v(i)+0.5*h*k1_v);
        k2_y = v(i)+0.5*h*k1_v;
        k3_v = f2(y(i)+0.5*h*k2_y, v(i)+0.5*h*k2_v);
        k3_y = v(i)+0.5*h*k2_v;
        k4_v = f2(y(i)+h*k3_y, v(i)+h*k3_v);
        k4_y = v(i)+h*k3_v;
        y(i+1) = y(i) + (h/6)*(k1_y + 2*k2_y + 2*k3_y + k4_y);
        v(i+1) = v(i) + (h/6)*(k1_v + 2*k2_v + 2*k3_v + k4_v);
    end
end

%% Gráficos
figure('Position', [100 100 800 600]);

subplot(2,1,1);
plot(t, y, 'b', 'LineWidth', 2);
hold on; 
line([t(1) t(end)], [L L], 'Color', 'r', 'LineStyle', '--', 'LineWidth', 1.5);
title('Posição vs Tempo');
ylabel('Altura (m)'); 
legend('Posição', 'Comprimento da corda', 'Location', 'best');
grid on;

subplot(2,1,2);
plot(t, v, 'm', 'LineWidth', 2);
title('Velocidade vs Tempo');
ylabel('Velocidade (m/s)'); xlabel('Tempo (s)');
grid on;

%% Resultados
fprintf('=== RESULTADOS ===\n');
fprintf('Altura máxima alcançada: %.2f m\n', max(y));
fprintf('Velocidade máxima: %.2f m/s\n', min(v));
Maple 
# Modelo de Bungee Jumping - Solução Numérica no Maple

restart;
with(plots):
with(DEtools):

# Parâmetros do modelo
mc := 70:       # Massa (kg)
L := 50:        # Comprimento da corda (m)
k := 100:       # Rigidez (N/m)
c := 15:        # Amortecimento (Ns/m)
g := 9.81:      # Gravidade (m/s²)

# Equação diferencial
bungee_eq := diff(y(t), t$2) = 
    g - piecewise(y(t) < L, 0, (k/mc)*(y(t)-L) + (c/mc)*diff(y(t), t)):

# Condições iniciais
ics := y(0) = 0, D(y)(0) = 0:

# Solução numérica
sol := dsolve({bungee_eq, ics}, y(t), numeric, output=listprocedure):
Y := eval(y(t), sol):  # Posição
V := eval(diff(y(t), t), sol):  # Velocidade

# Cálculo do alongamento máximo
E := L + (mc * g) / k:
L_max := E + sqrt(E^2 - L^2):
printf("Alongamento máximo da corda: %.2f m\n", L_max);

# Plotagem
p1 := plot(Y, 0..60, color=blue, thickness=2, legend="Posição [m]",
           labels=["Tempo (s)", ""], title="Modelo de Bungee Jumping"):
p2 := plot(V, 0..60, color=red, thickness=2, legend="Velocidade [m/s]"):

display(p1, p2, size=[800,400]);

Referências Bibliográficas

+
  1. Chapra, S. C., & Canale, R. P. (2016). Métodos Numéricos para Engenharia (6ª ed.). McGraw-Hill.
  2. Palm, W. J. (2018). Introduction to MATLAB for Engineers (4ª ed.). McGraw-Hill.
  3. Alfredo Hugo Valença Morillo. "Modelo físico de um salto de Bungee Jumping com solução utilizando método de Runge Kutta" (2015)
  4. Ismail, K.A.R. e Moura, L.F.M. (2012). Métodos numéricos em mecânica dos fluidos. UNICAMP.

Resultados e Conclusões

Gráficos de resultado
Figura 1: Exemplo dos gráficos de posição e velocidade que serão gerados pelo código Python

Principais Conclusões