Você está na página 1de 9

CLCULO DA VELOCIDADE DE UM MSSIL UTILIZANDO MTODOS DE

CALCULO NUMERICO

Daniel Henrique Munhoz Cantera e Juma Belitzki, alunos do curso de Engenharia


Mecnica IST Joinville.

Resumo. Este artigo tem como objetivo demonstrar a utilizao de uma ferramenta
ministrada nas aulas de Clculo Numrico utilizando uma linguagem de programao C++
para resoluo de um problema prtico. Para a resoluo deste foi utilizado o mtodo de
Runge Kutta de ordem 4.

Palavras-chave: Runge Kutta, linguagem C++, Clculo Numrico.

1 INTRODUO

Breve Histrico sobre o estudo de caso


O problema sugerido consiste em calcular a velocidade de um mssil aps certo
tempo, onde a acelerao constante gerada pela emisso em jato de seus gases
combustveis e a sua resistncia com o ar sua desacelerao.

2 REFERENCIAL TEORICO

Um mssil com massa de 200N disparado com velocidade inicial 0m/s, sendo acelerado
por uma acelerao constante de 2000m/s. Como fora de arrasto aerodinmico
considera-se Fr = -2*v. Utilizando mtodo de Runge Kutta de ordem 4, com 10 iteraes e
passo escolher.

Figura 1 Exemplo de mssil lanado com velocidade inicial zero.

3 ANLISES DOS DADOS

Neste trabalho a velocidade do mssil dada pela equao v = (a -2*v)/(m-t)


Onde:
a = acelerao constante
v = velocidade
m = massa do foguete
t = tempo
Fr = resistncia do ar = (-2*v)

Foi utilizado o mtodo de Runge Kutta de ordem 4 para a resoluo do problema, onde o
passo pode ser escolhido, neste caso ser 10s.

A varivel X o tempo (t), e a varivel Y a velocidade (v), o passo (h) ser 10s.

4 - Estrutura do programa.
// =========================================
// Turma: ENG 344
// Aluno: Daniel, Juma
// =========================================
#include <stdio.h>
#include <iostream>
#include <cstdlib>
#include <string>
#include <windows.h>
#include <time.h>
#include <math.h>
#include <conio.h>
using namespace std;
int main()
{
float m;
float v;
float t;
float fr;
float v0;
float h;
float a;
float t0;
printf("Digite a massa do missil em Newtons : ");
scanf("%f",&m);
printf("\nDigite a velocidade inicial em m/s : ");
scanf("%f,",&v0);
printf("\nDigite o passo desejado : ");
scanf("%f",&h);
printf("\nDigite a aceleracao em m/s^2 : ");
scanf("%f",&a);
printf("\n\nDados fornecidos: \n ");
printf("\n m = massa = %f \n v0 = velocidade inicial = %f \n h = passo = %f \n a = aceleracao = %f \n\n - pressione uma tecla
para iniciar as iteracoes" , m, v0, h, a);
getch();
float k1;
float k2;
float k3;
float k4;
float v1;
k1 = h*((a-2*v0)/(m-t0));
k2 = h*((a-2*(v0+k1*0.5))/(m-(t0+h*0.5)));
k3 = h*((a-2*(v0+k2*0.5))/(m-(t0+h*0.5)));
k4 = h*((a-2*(v0+k3))/(m-(t0+h)));
v1 = v0+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no instante 1 = %f \n", k1, k2, k3, k4, v1);
float v2;
float t1;
t1 = t0+h;
k1 = h*((a-2*v1)/(m-t1));
k2 = h*((a-2*(v1+k1*0.5))/(m-(t1+h*0.5)));
k3 = h*((a-2*(v1+k2*0.5))/(m-(t1+h*0.5)));
k4 = h*((a-2*(v1+k3))/(m-(t1+h)));
v2 = v1+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n", k1, k2, k3, k4, v2);
float v3;
float t2;
t2 = t1+h;
k1 = h*((a-2*v2)/(m-t2));
k2 = h*((a-2*(v2+k1*0.5))/(m-(t2+h*0.5)));
k3 = h*((a-2*(v2+k2*0.5))/(m-(t2+h*0.5)));
k4 = h*((a-2*(v2+k3))/(m-(t2+h)));
v3 = v2+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n", k1, k2, k3, k4, v3);
float v4;
float t3;
t3 = t2+h;
k1 = h*((a-2*v3)/(m-t3));

k2 = h*((a-2*(v3+k1*0.5))/(m-(t3+h*0.5)));
k3 = h*((a-2*(v3+k2*0.5))/(m-(t3+h*0.5)));
k4 = h*((a-2*(v3+k3))/(m-(t3+h)));
v4 = v3+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n", k1, k2, k3, k4, v4);
float v5;
float t4;
t4 = t3+h;
k1 = h*((a-2*v4)/(m-t4));
k2 = h*((a-2*(v4+k1*0.5))/(m-(t4+h*0.5)));
k3 = h*((a-2*(v4+k2*0.5))/(m-(t4+h*0.5)));
k4 = h*((a-2*(v4+k3))/(m-(t4+h)));
v5 = v4+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n\n Apos 5 iteracoes \n\n velocidade no proximo instante = %f \n", k1,
k2, k3, k4, v5);
printf("\n\n Pressione qualquer tecla para mais 5 iteracoes \n\n");
getch();
float v6;
float t5;
t5 = t4+h;
k1 = h*((a-2*v5)/(m-t5));
k2 = h*((a-2*(v5+k1*0.5))/(m-(t5+h*0.5)));
k3 = h*((a-2*(v5+k2*0.5))/(m-(t5+h*0.5)));
k4 = h*((a-2*(v5+k3))/(m-(t5+h)));
v6 = v5+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n", k1, k2, k3, k4, v6);
float v7;
float t6;
t6 = t5+h;
k1 = h*((a-2*v6)/(m-t6));
k2 = h*((a-2*(v6+k1*0.5))/(m-(t6+h*0.5)));
k3 = h*((a-2*(v6+k2*0.5))/(m-(t6+h*0.5)));
k4 = h*((a-2*(v6+k3))/(m-(t6+h)));
v7 = v6+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n", k1, k2, k3, k4, v7);
float v8;
float t7;
t7 = t6+h;
k1 = h*((a-2*v7)/(m-t7));
k2 = h*((a-2*(v7+k1*0.5))/(m-(t7+h*0.5)));
k3 = h*((a-2*(v7+k2*0.5))/(m-(t7+h*0.5)));
k4 = h*((a-2*(v7+k3))/(m-(t7+h)));
v8 = v7+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n", k1, k2, k3, k4, v8);
float v9;
float t8;
t8 = t7+h;
k1 = h*((a-2*v8)/(m-t8));
k2 = h*((a-2*(v8+k1*0.5))/(m-(t8+h*0.5)));
k3 = h*((a-2*(v8+k2*0.5))/(m-(t8+h*0.5)));
k4 = h*((a-2*(v8+k3))/(m-(t8+h)));
v9 = v8+((k1+2*k2+2*k3+k4)/6);
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n", k1, k2, k3, k4, v9);
float v10;
float t9;
t9 = t9+h;
k1 = h*((a-2*v9)/(m-t9));
k2 = h*((a-2*(v9+k1*0.5))/(m-(t9+h*0.5)));
k3 = h*((a-2*(v9+k2*0.5))/(m-(t9+h*0.5)));
k4 = h*((a-2*(v9+k3))/(m-(t9+h)));
v10 = v9+((k1+2*k2+2*k3+k4)/6);
printf("\n\n Apos 10 iteracoes \n\n");
printf("\n\n k1 = %f \n k2 = %f \n k3 = %f \n k4 = %f \n velocidade no proximo instante = %f \n\n", k1, k2, k3, k4, v10);
system("pause");
getchar();
}

5 - RESULTADOS
Para uma melhor abrangncia do problema, a massa do mssil (m), a velocidade inicial
(v0), o passo (h) e a acelerao (a), podem ser escolhidos, logo so variveis. O
programa far 10 iteraes.

Aps 10 iteraes obtivemos o valor de 728,5 m/s.


Para efeitos de comparao, foi realizado o mesmo clculo, utilizando Euler. Segue
resultados:

Pode-se observar uma diferena de 4,76% na velocidade final. Atribui-se o erro ao fato do
mtodo de Runge Kutta de ordem 4 ser mais refinado que o mtodo de Euler.
E% = ((763,157898-728,502991)/( 728,502991))*100 = 4,76%

6 Concluso

Neste trabalho foi demonstrada a resoluo de um problema convencional utilizando


ferramentas computacionais, neste caso utilizando o mtodo de Runge Kutta de ordem 4.
Aps 10 iteraes obteve-se o resultado, com a possibilidade de troca de valores do
enunciado, e feita comparao entre dois mtodos numricos.

Algo que se fosse

resolvido sem assistncia computacional levaria muito tempo e com grande margem para
erros.