Trabalho de Prticas

Computacionais de Mecnica
Hugo Torres - 120322043
Joo Guerra - 120302025
Liliana Andrade - 120322039
Simo Joo - 120302050
Simo S 120302048

Data: 28 de Novembro 2012

1

ndice
1.Problema 1 ..............................................................................................................................................4
1.1.Introduo.........................................................................................................................................4
1.2.Determinao da soluo exacta ......................................................................................................4
1.3.Aplicao do mtodo de Euler ..........................................................................................................5
1.4.Como determinar o erro absoluto? ..................................................................................................6
1.5.Ser que a dependncia do erro linear? ........................................................................................7
1.6.Ser que a dependncia do erro quadrtica? ................................................................................8
1.7.Concluso ..........................................................................................................................................9
1.8.Anlise do cdigo do Problema 1 ...................................................................................................10
2.Problema 2 ............................................................................................................................................12
2.1.Introduo.......................................................................................................................................12
2.2.Determinao das soluo exactas .................................................................................................12
2.3.Comparao dos grficos ................................................................................................................13
2.4.Concluso ........................................................................................................................................14
2.5.Anlise do cdigo do Problema 2 ...................................................................................................15
3.Problema 3 ............................................................................................................................................17
3.1.Introduo.......................................................................................................................................17
3.2.Determinao da soluo exacta ....................................................................................................17
3.3.Aplicao do Mtodo de Runge-Kutta de segunda ordem .............................................................17
3.4.Como determinar o erro absoluto? ................................................................................................19
3.5.Comparao dos grficos das aproximaes ..................................................................................20
3.6.Concluso ........................................................................................................................................20
3.7.Anlise do cdigo do Problema 3 ...................................................................................................21
4.Problema 4 ............................................................................................................................................22
4.1.Introduo.......................................................................................................................................22
4.2.Integrao da equao diferencial..................................................................................................23
4.3.Grficos obtidos ..............................................................................................................................23
4.4.Concluso ........................................................................................................................................24
4.5.Anlise do cdigo do Problema 4 ...................................................................................................24

5.Problema 5 ............................................................................................................................................26
5.1.Introduo.......................................................................................................................................26
5.2.Construo e anlise dos grficos ...................................................................................................26
5.3.Concluso ........................................................................................................................................29
5.4.Anlise do cdigo do Problema 5.29
6.Problema 6 ............................................................................................................................................31
6.1.Introduo.......................................................................................................................................31
6.2.Comparao dos integradores ........................................................................................................32
6.3.Comparao e anlise dos grficos .................................................................................................33
6.4.Concluso ........................................................................................................................................36
6.5.Anlise do cdigo do Problema 6 ...................................................................................................36
7.Problema 7 ............................................................................................................................................39
7.1.Introduo.......................................................................................................................................39
7.2.Como passar os argumentos para a lista de valores t? ..................................................................39
7.3.Testando o cdigo ...........................................................................................................................40
7.4.Concluso ........................................................................................................................................41
7.5.Anlise do cdigo do Problema 7 ...................................................................................................41

1. Problema 1
No problema de atrito de Stokes a soluo exacta conhecida. Estude a dependncia no erro
de clculo de v(t+h) em funo de h num passo de Euler. A dependncia linear, quadrtica?
1.1. Introduo
Este problema pede-nos para encontrar a relao entre o erro num passo do Mtodo de Euler e
o tamanho deste passo quando este assume valores pequenos.
1.2. Determinao da soluo exacta:
A fora de atrito de stokes uma fora que depende da velocidade a que o corpo se desloca,
segundo a equao:

Integrando, obtemos:

Tomando

1.3.Aplicao do Mtodo de Euler:

Da definio de derivada, vem:
|
Para um h suficientemente pequeno:
|

Rearranjando os termos, obtemos um passo do Mtodo de Euler:

|
|
Recordemos que, da equao diferencial, vem:
|
Logo, com

Para

, temos:

Este o passo do Mtodo de Euler para o instante inicial. Para obter os pontos seguintes,
necessrio repetir o passo
, actualizando
de cada vez que
queremos computar o prximo ponto. Como isto se trata de uma aproximao, natural que
haja um erro subjacente, que o que queremos estudar. Para efectuar no Python um passo do
Mtodo de Euler, usamos o cdigo da funo eulerstep que nos foi fornecida nas aulas
prticas:
def eulerstep(func,x0,h):
return x0+func(x0)*h

1.4. Como determinar o erro absoluto?

Para encontrar o erro absoluto associado ao Mtodo de Euler em funo do tamanho do passo,
procedemos do seguinte modo:
1. Fixamos um ponto . Escolhemos o ponto inicial
, pois j conhecemos o valor
da velocidade nesse ponto,
.
2. Utilizando um passo do Mtodo de Euler para um determinado h, determinamos o valor
aproximado da velocidade no ponto seguinte,
.
3. Usando a soluo exacta da equao que obtivemos, calculamos a velocidade nesse
mesmo ponto
.
4. Achamos a diferena entre os dois valores
, de modo a
encontrar o erro absoluto para esse novo ponto.
De modo a estudar a dependncia do erro absoluto, repetimos este processo para vrios valores
de h.
erro=zeros((npoints,2),float)
i=0
for j in range(npoints):
erro[j,0]=i
erro[j,1]=abs(fsol(i)-eulerstep(fint,x0,i))
i=i+soma
i=0
Ofor
grfico
para o erro absoluto em funo de h, atravs da funo plot, o seguinte:
j obtido
in range(101):
erro[j,0]=i
erro[j,1]=abs(fsol(i)-eulerstep(fint,x0,i))
i=i+soma

plot(erro[:,0],erro[:,1],'r')
xlabel('h')
ylabel('erro')
title('Estudo do erro num passo do Metodo de Euler')
legend(('Exacto'))
show()

1.5.Ser que a dependncia do erro linear?

Tentamos agora encontrar a recta que melhor se ajusta aos dados. Isto conseguido atravs de
uma regresso linear. No python, utilizamos a funo polyfit (dentro de uma funo
adjust que diz qual o grau do polinmio pretendido) para determinar os coeficientes dessa
recta. De seguida, criamos uma matriz, matriz, para armazenar os valores da recta para cada
valor do passo do Mtodo de Euler, de modo a poder compar-los mais tarde.
def adjust(ordem):
matriz=zeros((npoints,2),float)
coeford=polyfit(erro[:,0],erro[:,1],ordem)
i=0
def eq(x):
eq=0
for m in range(ordem+1):
eq=eq+coeford[m]*(x**(ordem-m))
m=m+1
return eq
for j in range(npoints):
matriz[j,0]=i
matriz[j,1]=eq(i)
i=i+next
return matriz
lin=adjust(1)

Novamente, atravs da funo plot, podemos obter este grfico e a sobreposio dele com o
do erro absoluto exacto:

plot(erro[:,0],erro[:,1],'r',lin[:,0],lin[:,1],'g')
xlabel('h')
ylabel('erro')
title('Estudo do erro num passo do Metodo de Euler')
legend(('Exacto','1 Grau'))
show()
Facilmente se conclui, pela anlise dos dois grficos, que a dependncia no linear.
7

1.6.Ser que a dependncia do erro quadrtica?

Como tentmos ajustar uma recta ao grfico e falhmos, tentamos desta vez ajustar uma curva.
Utilizando o mesmo processo para armazenar os dados, recorremos de novo funo polyfit e
determinamos os coeficientes do polinmio de grau 2 que melhor se ajusta aos dados.

def adjust(ordem):
matriz=zeros((npoints,2),float)
coeford=polyfit(erro[:,0],erro[:,1],ordem)
i=0
def eq(x):
eq=0
for m in range(ordem+1):
eq=eq+coeford[m]*(x**(ordem-m))
m=m+1
return eq
for j in range(npoints):
matriz[j,0]=i
matriz[j,1]=eq(i)
i=i+next
return matriz
quad=adjust(2)

A funo plot devolve-nos os seguintes grficos:

Daqui podemos concluir que a dependncia do erro num passo do Mtodo de Euler
quadrtica, porque ajusta-se muito bem ao grfico de um polinmio do segundo grau.
plot(erro[:,0],erro[:,1],'r',quad[:,0],quad[:,1],'b--')
xlabel('h')
ylabel('erro')
title('Estudo do erro num passo do Metodo de Euler')
legend(('Exacto','2 Grau'))
show()
8

1.7.Concluso:
Utilizando o Mtodo de Euler na equao diferencial que traduz o atrito de Stokes, sabemos
que h um erro associado escolha do tamanho do passo. Este erro pode ser minimizado
tomando um passo muito pequeno, mas est sempre presente, pois este mtodo trata-se de uma
aproximao. Assim, decidimos ver de que forma que este erro varia com a escolha do passo
para termos uma melhor noo de como este mtodo funciona. Ajustando rectas e curvas ao
grfico do erro absoluto, chegmos concluso que a dependncia do erro quadrtica, pois
ajusta-se ao grfico de uma funo polinomial do 2 grau.

1.8. Anlise do cdigo do Problema 1:

Comeamos por importar os mdulos do Python que nos interessam: scipy, pylab e
numpy, e definimos as variveis que sero relevantes para o problema.
from scipy import *
from pylab import *
from numpy import *
t0=0
x0=1
hmax=0.4
npoints=100
next=hmax/npoints
Em seguida, definimos a funo eulerstep, sendo func a funo a integrar, x0 o ponto da
curva soluo e h o tamanho do passo do Mtodo de Euler.
def eulerstep(func,x0,h):
return x0+func(x0)*h
fsol a soluo exacta para a equao diferencial do atrito de stokes.
def fsol(x):
return exp(-x)
fint
|

a funo a integrar numericamente. Vem da equao diferencial que

.

def fint(x):
return -x
Definimos a matriz erro de duas colunas para armazenar os valores a por no grfico.
Preenchemos a primeira coluna com o valor de h e segunda coluna com a diferena entre o
valor exacto e o valor aproximado obtido pelo Mtodo de Euler.
erro=zeros((npoints,2),float)
i=0
for j in range(101):
erro[j,0]=i
erro[j,1]=abs(fsol(i)-eulerstep(fint,x0,i))
i=i+next
i=0
for j in range(101):
erro[j,0]=i
erro[j,1]=abs(fsol(i)-eulerstep(fint,x0,i))
i=i+soma

10

Depois, de modo a no ter de repetir o processo para cada grau de aproximao, criamos a
funo adjust que determina o grau da funo polyfit e nos devolve uma matriz com os
valores da recta/curva correspondente, para cada valor de h.
def adjust(ordem):
matriz=zeros((npoints,2),float)
coeford=polyfit(erro[:,0],erro[:,1],ordem)
i=0
def eq(x):
eq=0
for m in range(ordem+1):
eq=eq+coeford[m]*(x**(ordem-m))
m=m+1
return eq
for j in range(npoints):
matriz[j,0]=i
matriz[j,1]=eq(i)
i=i+next
return matriz
Assim, depois de criada esta funo, torna-se fcil obter as matrizes lin e quad para uma
regresso linear e para uma regresso quadrtica, respectivamente.
lin=adjust(1)
quad=adjust(2)
Finalmente, implementamos a funo que cria os grficos.
plot(erro[:,0],erro[:,1],'r',lin[:,0],lin[:,1],'g',quad[:,0],
quad[:,1],'b--')
xlabel('h')
ylabel('erro')
title('Estudo do erro num passo do Metodo de Euler')
legend(('Exacto','1 Grau','2 Grau'))
show()

11

2. Problema 2
Considere o caso de atrito de Newton,

Compare os amortecimentos de Stokes e Newton para valores iniciais de v e

iguais.

2.1.Introduo:
Este problema pede-nos para comparar dois regimes diferentes: o de atrito de Newton e o de
atrito de Stokes. No caso do atrito de Stokes, a fora varia linearmente com a velocidade, mas
no caso do atrito de Newton, a fora varia com o quadrado da velocidade, por isso de esperar
que as funes se comportem de modo diferente.
2.2.Determinao das solues exactas:
De modo a comparar analiticamente as duas funes, e ter uma referncia quando
implementarmos o Mtodo de Euler, faz sentido encontrar a soluo exacta para cada uma
delas.
A soluo para a fora de atrito de Stokes j conhecida do Problema 1:

E a soluo para a fora de atrito de Newton pode ser facilmente derivada:

12

Tomando as mesmas condies iniciais do problema anterior,

Como a funo do atrito de Stokes varia com uma exponencial e a do atrito de Newton com um
inverso do tempo, ser de esperar que a primeira funo decresa mais rapidamente do que a
segunda.
2.3.Comparao dos grficos:
Para comparar os dois amortecimentos para valores de velocidade e acelerao iguais, tomamos
os coeficientes como parmetros e calculamos a velocidade inicial em funo destes.

Logo,

Podemos retirar o caso em que

movem. Assim:

Tomando

pois esse o caso trivial em que os corpos no se

, podemos finalmente comparar os grficos atravs da funo

plot.

13

plot(mstokes[:,0],mstokes[:,1],'r',mnewton[:,0],mnewton[
:,1],'g')
xlabel('tempo')
ylabel('velocidade')
title('Amortecimento de Stokes e de Newton')
legend(('Stokes','Newton',))
show()

Vemos claramente que sob as mesmas condies iniciais e para coeficientes iguais, a funo do
atrito de Stokes decresce mais rapidamente do que o do atrito de Newton, desde o instante
inicial, tal como previsto pela anlise das solues das equaes diferenciais. Mas ser que este
resultado se mantm para diferentes coeficientes?

Se olharmos simplesmente para o quociente entre as duas velocidades, nada nos garante qual
dos amortecimentos mais forte no incio, mas se tomarmos o limite quando
, fcil
ver que a exponencial vai dominar, independentemente do valor dos coeficientes. No entanto,
se os coeficientes forem iguais, fazendo uma expanso de Taylor para a exponencial volta do
ponto

, com

, ficamos com:

O que prova que para coeficientes e massas iguais, uma partcula sujeita ao amortecimento de
Stokes ter sempre velocidade menor do que uma partcula sujeita ao amortecimento de
Newton.
2.4.Concluso:
O atrito de Stokes e o atrito de Newton dependem ambos da velocidade a que o corpo em
questo se move. No entanto, como o atrito de Stokes varia linearmente com a velocidade, vai
decrescer mais rapidamente do que o atrito de Newton, que varia com o quadrado da
velocidade. Quer isto dizer que uma partcula sujeita somente ao atrito de Stokes, parar mais
rapidamente do que uma partcula sujeita ao atrito de Newton.

14

2.5.Anlise do cdigo do Problema 2:

Comeamos por importar os mdulos que sero relevantes para o problema: scipy e pylab e
definimos o passo do Mtodo de Euler em funo da quantidade de pontos que queremos.
From scipy import *
from pylab import *
npoints=100
h=3.0/npoints
Em seguida, definimos a funo eulerstep, sendo func a funo a integrar, x0 o ponto da
curva soluo e h o tamanho do passo do Mtodo de Euler. A funo euler preenche as
tabelas de dados com os pontos encontrados pela funo eulerstep. t0 o instante em
questo.
def eulerstep(func,x0,h):
return x0+func(x0)*h
def euler(func):
t0=0
x0=1
inserir=zeros((npoints+1,2),float)
for j in range(npoints+1):
inserir[j,0]=t0
inserir[j,1]=x0
x0=eulerstep(func,x0,h)
t0=t0+h
j=j+1
return inserir
Definimos as funes stokes e newton que sero chamadas para a funo eulerstep
pela funo euler de modo a preencher as tabelas mstokes e mnewton, respectivamente.
def stokes(v):
return -v
def newton(v):
return -v**2
mstokes=euler(stokes)
mnewton=euler(newton)

15

Por fim, implementamos a funo plot que nos devolve o grfico.

plot(mstokes[:,0],mstokes[:,1],'r',mnewton[:,0],mnewton[
:,1],'g')
xlabel('tempo')
ylabel('velocidade')
title('Amortecimento de Stokes e de Newton')
legend(('Stokes','Newton',))
show()

16

3. Problema 3
Resolva a mesma questo do Problema 1 na pgina 6 para um passo de Runge-Kutta de
segunda ordem.
3.1.Introduo
semelhana do Problema 1, -nos pedido para encontrar a dependncia do erro em funo de h
quando este assume valores pequenos, mas desta vez, usamos um mtodo um pouco diferente, o Mtodo
de Runge-Kutta de segunda ordem. Tal como o Mtodo de Euler, obtemos somente uma aproximao
da funo-soluo exacta, portanto obteremos um erro, e esse erro que queremos estudar.

3.2.Determinao da soluo exacta:

A soluo exacta para a equao diferencial do atrito de Stokes j foi determinada no Problema
1:

3.3.Aplicao do Mtodo de Runge-Kutta de segunda ordem:

O Mtodo de Runge-Kutta de ordem 2 assume que o declive da
recta que une os pontos
e
aproximadamente igual
ao declive da recta tangente ao grfico da funo no ponto entre
e
, o ponto
. Assim, vem que:

Como

:
(

Como no sabemos o valor da funo no ponto

, recorremos a uma expanso de Taylor

sobre o ponto :

17

Como este mtodo de segunda ordem, s nos interessam os dois primeiros termos:

)
(

Juntando as duas equaes, obtemos:

(

Este um passo do Mtodo de Runge-Kutta de segunda ordem para a equao diferencial que
traduz o atrito de Stokes:

Agora, -nos possvel computar cada um dos pontos seguintes, dentro do erro desejado, com
um passo Mtodo de Runge-Kutta de ordem 2. Mais uma vez, como se trata apenas de uma
aproximao, h um erro associado, que o que queremos estudar. Para implementar esta
funo no Python, usaremos a funo rk2step que foi fornecida nas aulas prticas:
def rk2step(func, x0,h):
k0= func(x0)*h
return x0+func(x0+0.5*k0)*h

18

3.4.Como determinar o erro absoluto?

Tal como para o Mtodo de Euler no Problema 1, para encontrar o erro absoluto associado ao
Mtodo de Runge-Kutta de ordem 2 (RK2) em funo do tamanho do passo, procedemos do
seguinte modo:
5. Fixamos um ponto . Escolhemos o ponto inicial
, pois j conhecemos o valor
da velocidade nesse ponto,
.
6. Utilizando um passo de RK2 para um determinado h, determinamos o valor aproximado
da velocidade no ponto seguinte,
.
7. Usando a soluo exacta da equao que obtivemos, calculamos a velocidade nesse
mesmo ponto
.
8. Achamos a diferena entre os dois valores
, de modo a
encontrar o erro absoluto para esse novo ponto.
De modo a estudar a dependncia do erro absoluto, repetimos este processo para vrios valores
de h.
erro=zeros((npoints,2),float)
i=0
for j in range(npoints):
erro[j,0]=i
erro[j,1]=abs(fsol(i)-rk2step(fint,x0,i))
i=i+soma
i=0
Ofor
grfico
em funo de h o seguinte:
j do
inerro
range(101):
erro[j,0]=i
erro[j,1]=abs(fsol(i)-eulerstep(fint,x0,i))
i=i+soma

plot(erro[:,0],erro[:,1],'b')
xlabel('h')
ylabel('erro')
title(Estudo do erro num passo do Metodo de Runge-Kutta
de segunda ordem)
legend(('Exacto'))
show()
19

3.5.Comparao dos grficos das aproximaes:

Se sobrepusermos os grficos, vemos claramente que a dependncia do erro cbica, pois o

grfico da funo polinomial cbica que melhor se ajusta ao erro absoluto em funo de h.
3.6.Concluso:
Utilizando o Mtodo de Runge-Kutta de segunda ordem na equao diferencial que traduz o
atrito de Stokes, podemos concluir que, embora ainda haja um erro subjacente ao mtodo, este
erro menor do que o erro obtido atravs do Mtodo de Euler (basta olhar para o eixo das
ordenadas para ver que os valores do erro so muito mais pequenos). Isto permite-nos obter
uma aproximao numrica muito precisa e que no requer tanto tempo de processamento do
programa como o Mtodo de Euler. Para alm disso, verificamos que a dependncia do erro
devido escolha do valor de h cubica. Isto deve-se ao facto de termos usado a expanso de
Taylor somente at ao termo do segundo grau.

20

3.7.Anlise o cdigo do Problema 3:

O cdigo para o Problema 3 essencialmente igual ao do Problema 1. As nicas diferenas
consistem no seguinte:
Utilizamos um integrador diferente. Em vez de eulerstep, usamos rk2step:
def rk2step(func, x0,h):
k0=func(x0)*h
return x0+func(x0+0.5*k0)*h
Depois de definida a funo adjust, criamos mais uma matriz para alm de lin e quad, a
matriz cube, que corresponde a uma regresso cbica:
lin=adjust(1)
quad=adjust(2)
cube=adjust(3)

Finalmente,
adicionamos um termo funo plot, correspondente a essa regresso cbica:
c
plot(erro[:,0],erro[:,1],'r',lin[:,0],lin[:,1],'g--',
quad[:,0],quad[:,1],'y--',cube[:,0],cube[:,1],'b--')
xlabel('h')
ylabel('erro')
title(Estudo do erro num passo do Metodo de Runge-Kutta
de ordem 2')
legend(('Exacto','1 Grau','2 Grau','3 Grau'))
show()

21

4. Exerccio 4
Estude o caso de queda livre de um corpo na atmosfera (sentido positivo z, ascendente) pelo
mtodo de rk2, determinando a funo
. A fora segundo z :

Considere queda na vertical, com velocidade inicial

e produza grficos
comparativos para diferentes valores de . No se esquea de reduzir dimensionalmente as
equaes.
4.1.Introduo
Neste problema, -nos pedido para estudar o caso de um corpo em queda livre sujeito ao
amortecimento de Newton atravs da construo de grficos para vrios valores do coeficiente
.
A equao que nos d a fora resultante no corpo :

Como o movimento sempre descendente, a velocidade ter sinal negativo, logo podemos
simplificar a equao:

Para obtermos a acelerao, basta dividir a equao por m:

Como o que ns queremos estudar a dependncia entre velocidade e a constante de Newton,

temos que efectuar uma substituio que tire as outras constantes da equao:

Deste modo temos:

Logo, teremos tambm que tomar um em funo de t:

Obtendo-se assim o resultado final:

22

Com esta equao, podemos comear a estudar a dependncia entre a velocidade e

Adicionalmente, como sabemos que
, ento
.
4.2. Integrao

da equao diferencial

Como j explicado no problema ser utilizado o Mtodo de Runge-Kutta de ordem 2 para fazer a
aproximao da funo. Neste trabalho iro ser utilizados 100 pontos, um h de 0,1 e 4 valores distintos
de : 0.33,1,4 e 8.
Com vista a agrupar as matrizes que tinham os dados sobre os tempos e as respetivas velocidades para
cada constante, crimos uma lista chamada matrizes onde foram colocadas as 4 matrizes
correspondentes aos 4 valores de .

matrizes=[]
for gamma in[0.33,1,4,8]:
traj=zeros((100,2),float)
for i in range(100):
traj[i,0]=t0
traj[i,1]=x0
x0=rk2(az,x0,h)
t0+=h
matrizes.append(traj)
t0=0
x0=0
4.3. Grficos

obtidos:

plot(matrizes[0][:,0],matrizes[0][:,1],'r',matrizes[1][:
,0],matrizes[1][:,1],'g',matrizes[2][:,0],matrizes[2][:,
1],'b',matrizes[3][:,0],matrizes[3][:,1],'y')
xlabel('tempo')
ylabel('velocidade')
title('Variacao da velocidade de um corpo em queda livre
com resistencia do ar')
legend(('gama=0.33','gama=1','gama=4','gama=8'))
show()
23

4.4. Concluso

Atravs da anlise do grfico obtido, conclumos que a velocidade terminal do corpo tanto
maior quanto menor for . Isto deve-se ao facto de
ser proporcional resistncia do ar
(como se pode ver na frmula que nos dada no problema), o que significa que quanto menor
for a resistncia do ar, maior ser a velocidade terminal atingida
Alm disso, tambm se verifica que quanto maior for
menos acelerado o movimento. Isto
deve-se ao facto descrito no pargrafo anterior, porque quanto maior for , maior a fora
ascendente sobre o corpo. Assim, como a acelerao exercida pela resistncia do ar no corpo
maior, ento a acelerao final ser menor.
4.5. Anlise

do cdigo do Problema 4:

Comeamos por importar os mdulos que nos interessam e definir as variveis que sero
relevantes para o problema: o tempo inicial t0, a posio inicial x0 e o tamanho do passo h.
from
from
from
from

scipy import *
pylab import *
numpy import *
matplotlib import *

t0=0
x0=0
h=0.1
Em seguida, definimos a funo az que nos d a funo a integrar:
def az(vz):
return gamma*(vz**2)-1
rk2 a funo que representa o passo do Mtodo de Runge-Kutta de segunda ordem.
def rk2(func,x0,h):
k= func(x0)*h
return x0+func(x0+k/2)*h

24

Depois, criamos um ciclo para preencher as tabelas com os valores das funes para cada

matrizes=[ ]
for gamma in[0.33,1,4,8]:
traj=zeros((100,2),float)
for i in range(100):
traj[i,0]=t0
traj[i,1]=x0
x0=rk2(az,x0,h)
t0+=h
matrizes.append(traj)
t0=0
x0=0
Por fim, usamos a funo plot para desenhar o grfico:
plot(matrizes[0][:,0],matrizes[0][:,1],'r',matrizes[1][:
,0],matrizes[1][:,1],'g',matrizes[2][:,0],matrizes[2][:,
1],'b',matrizes[3][:,0],matrizes[3][:,1],'y')
xlabel('tempo')
ylabel('velocidade')
title('Variacao da velocidade de um corpo em queda livre
com resistencia do ar')
legend(('gama=0.33','gama=1','gama=4','gama=8'))
show()

25

5. Problema 5
O problema 2 na pgina II ficou um pouco incompleto por no termos determinado

em
conjunto com
. Corrija este facto usando um sistema de equaes de primeira ordem. Estude de
novo o caso de queda livre de um corpo na atmosfera (sentido positivo z, ascendente) pelo mtodo de
rk2, determinando agora no apenas
mas tambm
e
. Estude parmetros como o
tempo de queda em funo da altura inicial e a a velocidade ao atingir o solo em funo da altura de
queda, para diferentes valores de .

5.1.Introduo
Este problema pede-nos para estudar a variao dos tempos e velocidades de queda comparativamente
altura de queda (v(t), z(t), v(z)), relativamente ao exerccio 4. Para podermos criar grficos comparativos
temos de dar valores a
e a . Assim sendo, vamos estudar cada grfico mantendo um parmetro
constante e variando o outro.

5.2.Construo e anlise dos grficos:

O primeiro grfico o grfico da posio em funo do tempo para diferentes valores de
para h constante.

26

Desta vez, mantemos

tempo

constante e variamos a altura inicial h num grfico da posio em funo do

No terceiro grfico, variamos

posio.

, mantendo h constante num grfico da velocidade em funo da

27

No quarto grfico, da velocidade em funo da posio, mantemos

constante e variamos h.

28

5.3.Concluso
Atravs da anlise dos grficos posio-tempo, podemos concluir que o tempo de queda
afectado tanto por
como pela altura.
afecta o tempo de queda na medida em que, como
visto no problema anterior, quanto maior este for, menor ser a velocidade terminal, e quanto
menor for a velocidade mais tempo leva a chegar ao solo. Relativamente altura, obviamente
que quanto menor esta for, mais perto est o corpo do cho, logo menos tempo levar a
alcan-lo.
No grfico velocidade-posio, podemos igualmente observar que quanto menor for
maior
ser a acelerao do corpo, e consequentemente, maior ser a velocidade ao chegar ao solo,
pois como visto anteriormente, maior ser a velocidade terminal. No que toca ao grfico em
que a altura de que o corpo lanado varivel, podemos verificar que a velocidade com que o
corpo atinge o solo s varia se a altura for to baixa que o corpo no tenha tempo de atingir a
velocidade terminal, o que acontece quando o corpo largado de altura de 1m.
5.4.Anlise do cdigo do Problema 5:
Comeamos por importar os mdulos necessrios e definimos as variveis que sero utilizadas
pelo programa. h0 e gama so variveis que sero inseridas durante o decorrer do programa.
from scipy import*
from pylab import*
from numpy import*
v0=0
h0=float(input("Altura inicial?"))
gama=float(input("Gama?"))
t0=0
tf=10.0
npoints=100
h=tf/npoints
x0=array([h0,v0])
yterra=array([[0.,0.],[tf,0.]])
A funo f a funo que devolve os valores da velocidade e da acelerao em funo do
instante anterior e ser usada por rk2.
def f(x):
y=zeros(2,float)
y[0]=x[1]
y[1]=gama*x[1]**2-1
return y

29

As funes rk2step e rk2 j so conhecidas dos problemas anteriores.

def rk2step(func,x0,h):
k0=func(x0)*h
return x0+func(x0+0.5*k0)*h
def rk2(func,t0,x0,h,npoints):
traj=zeros((npoints,len(x0)+1),float)
for i in range(npoints):
traj[i,0]=t0
traj[i,1:len(x0)+1]=x0
x0=rk2step(f,x0,h)
t0+=h
return traj
Por fim, definimos a funo plot que nos desenha os trs grficos:
figure(1)
plot(dados[:,0],dados[:,2])
xlabel('tempo')
ylabel('velocidade')
title('Queda de um corpo na atmosfera')
figure(2)
plot(dados[:,0],dados[:,1],'r',yterra[:,0],yterra[:,1],'
b')
xlabel('tempo')
ylabel('posicao')
title('Queda de um corpo na atmosfera')
figure(3)
plot(dados[:,1],dados[:,2])
xlabel('posicao')
ylabel('velocidade')
title('Queda de um corpo na atmosfera')
show()

30

6. Problema 6:
Compare o integrador rk2 com odeint para o problema do oscilador amortecido. Calcule
as diferenas entre as solues dadas por cada um destes mdulos para diferentes valores do
passo de integrao usado em rk2.
6.1.Introduo:
Neste exerccio -nos pedidos para comparar os resultados obtidos por dois integradores:
odeint (integrador existente no mdulo integrate.scipy) e rk2 (Mtodo de Runge-Kutta de
ordem 2, integrador fornecido nas aulas prticas).
Para compararmos estes dois integradores iremos estudar o problema do oscilador
amortecido que est no texto-guia.

De modo a resolver esta equao numericamente, tal como vimos no texto-guia, reduzimos a
equao a um sistema de duas equaes de primeira ordem:

Se medirmos o tempo em unidades de , ficamos com:

E obtemos as seguintes expresses:

{

, onde

Implementaremos esta funo no python para ser integrada por rk2.

def func(x):
y=zeros(2,float)
y[0]=x[1]
y[1]=-x[0]-0.1*x[1]
return y

31

Uma expresso semelhante ser usada pelo integrador odeint:

def f(x,t):
return (x[1],-x[0]-0.1*x[1])
de esperar que, por usarmos integradores diferentes, as funes tero argumentos diferentes.
No entanto, como se referem s mesmas condies iniciais para a mesma equao, os
resultados sero os mesmos.
6.2.Comparao dos integradores:
A primeira grande diferena entre os dois integradores que o integrador odeint usa uma
lista de tempos e devolve o valor da funo em cada ponto dessa lista, enquanto que o
integrador rk2 utiliza um tempo inicial, e atravs de um valor de h (o tamanho do passo),
calcula o valor da funo no instante
, procedendo da mesma forma nos pontos seguintes
at atingir o nmero de iteraes desejado. De modo a poder comparar os dois integradores,
faremos com que odeint aceite uma lista de tempos equivalente aos utilizados por rk2.
Tomaremos os valores de t0=0 e tf=40:
t=arange(t0,tf,h)

Para o odeint iremos utilizar

e para o mtodo de rk2 utilizaremos
h={0.02,0.05,0.1,0.2,0.5} na forma de uma lista, hrk2.
De modo a criar os grficos, precisamos de armazenar os resultados em tabelas:
hrk2=[0.02,0.05,0.1,0.2,0.5]
def chooseh(i):
matriz=rk2(func,t0,x0,hrk2[i],int(tf/hrk2[i]))
return matriz
dados1=chooseh(0)
dados2=chooseh(1)
...
Esta funo permite-nos criar tabelas de pontos com o h que quisermos da lista de valores de h
que inserirmos. Note-se que o nmero de pontos varia com o h escolhido, para que os grficos
tenham o mesmo tamanho.

32

6.3.Comparao e anlise dos grficos:

Agora que j temos uma tabela com os pontos das funes para cada um dos cinco valores
diferentes de h para rk2 e uma tabela com os pontos obtidos por odeint, j podemos
comparar os grficos, com recurso funo plot:

figure(1)
plot(t,odinty[:,0],'r',dados1[:,0],dados1[:,1],'b',dados
2[:,0],dados2[:,1],'y--',dados3[:,0],dados3[:,1],'g-',dados4[:,0],dados4[:,1],'r-',dados5[:,0],dados5[:,1],'b--')
xlabel("tempo")
ylabel("amplitude")
title("Comparacao dos integradores rk2 e odeint")
legend(('odeint h=0.2','rk2 h=0.02','rk2 h=0.05','rk2
h=0.1','rk2 h=0.2','rk2 h=0.5'))
show()
Neste grfico j podemos ver considerveis diferenas quando o tamanho do passo de rk2
0.5. De modo a poder comparar melhor os outros valores, fazemos um zoom do grfico:

33

Aqui j possvel ver que os vrios grficos comeam a divergir. No entanto, rk2 h=0.02 e
odeint h=0.2 permanecem muito prximos. Seria de esperar que odeint h=0.2, tendo
um passo dez vezes maior do que rk2 h=0.02, tivesse um erro maior. Normalmente um
passo maior implica uma pior aproximao. No entanto, isto no se verifica, o que mostra que
odeint um integrador eficiente.
De modo a melhor comparar os vrios grficos, definimos uma nova funo, com o objectivo
de calcular a diferena entre odeint e rk2 para cada valor de h na lista inserida.
def diferenca(dados):
dif=zeros((len(odinty),2),float)
c=len(dados)/len(odinty)
for i in range(len(odinty)):
dif[i,0]=dados[c*i,0]
dif[i,1]=dados[c*i,1]-odinty[i,0]
return dif
dif4=diferenca(dados4)
dif3=diferenca(dados3)
dif2=diferenca(dados2)
dif1=diferenca(dados1)
Daqui retirmos h=0.5, porque demasiado divergente e porque a funo s aceita tabelas
cuja quantidade de pontos um mltiplo do nmero de pontos de odinty.

34

Assim, obtemos o seguinte grfico:

figure(2)
plot(dif1[:,0],dif1[:,1],'b',dif2[:,0],dif2[:,1],'y',dif
3[:,0],dif3[:,1],'g',dif4[:,0],dif4[:,1],'r')
xlabel("tempo")
ylabel("diferenca")
title("Diferenca entre os integradores rk2 e odeint")
legend(('h=0.02','h=0.05','h=0.1','h=0.5'))
show()
Agora podemos ver claramente a diferena entre os dois integradores para cada valor de h
utilizado em rk2. Quanto mais pequeno for o h, menor ser a diferena entre os dois
integradores, de tal modo que a diferena quase imperceptvel para h=0.02. S se
aproximarmos a imagem que podemos ver essa diferena:

35

6.4.Concluso
Da anlise dos grficos, podemos concluir que os integradores odeint com h=0.2 e rk2
com h=0.02 so os mais precisos. No entanto, h uma diferena fundamental entre os dois: o
integrador odeint, por ter um passo maior, precisa de menos pontos para desenhar o grfico,
mas mantm uma grande preciso. rk2, apesar de fazer um grfico mais suave, precisa de
dez vezes mais pontos para obter a mesma preciso que odeint. Isto implica um tempo de
processamento muito maior, o que torna o integrador odeint mais eficiente.
6.5.Anlise do cdigo do Problema 6:
Depois de importar os mdulos que sero necessrios, definimos as variveis que faro parte do
nosso cdigo: t0 o instante inicial, x0 a posio inicial, h o tamanho do passo de odeint,
hrk2 a lista dos valores de h que sero introduzidos em rk2 e tf o instante final.
pontos garante que os grficos comeam e terminam nos mesmos instantes.
from scipy import*
from pylab import*
import scipy.integrate
t0=0
x0=array([1.,0.])
h=0.2
hrk2=[0.02,0.05,0.1,0.2,0.5]
tf=40
pontos=tf/h
A funo f a funo que devolve os valores da velocidade e da acelerao em funo do
instante anterior. t d-nos a lista de tempos a ser utilizada por
odinty=scipy.integrate.odeint(f,x0,t).
def f(x,t):
return (x[1],-x[0]-0.1*x[1])
t=arange(t0,tf,h)
odinty=scipy.integrate.odeint(f,x0,t)
Em seguida, definimos a funo func que actua como a funo f mas com um formato que possa ser
utilizado por rk2.

def func(x):
y=zeros(2,float)
y[0]=x[1]
y[1]=-x[0]-0.1*x[1]
return y
Definimos a funo rk2step e rk2 tal como j foi feito nos outros problemas:

36

def rk2step(func,x0,h):
k0= func(x0)*h
return x0+func(x0+0.5*k0)*h
def rk2(func,t0,x0,h,npoints):
traj=zeros((npoints,len(x0)+1),float)
for i in range(npoints):
traj[i,0]=t0
traj[i,1:len(x0)+1]=x0
x0=rk2step(func,x0,h)
t0+=h
return traj
A funo choose vai-nos devolver uma tabela com os valores das funes integradas por
rk2, tomando como argumento a posio dos elementos na lista hrk2. Depois, definimos as
cinco tabelas correspondentes s funes para cada h.
def chooseh(i):
matriz=rk2(func,t0,x0,hrk2[i],int(tf/hrk2[i]))
return matriz
dados1=chooseh(0)
dados2=chooseh(1)
dados3=chooseh(2)
dados4=chooseh(3)
dados5=chooseh(4)
A funo diferenca vai fazer a diferena entre odeint e rk2 para cada ponto. Em
seguida, definimos quatro tabelas com esses valores.
def diferenca(dados):
dif=zeros((len(odinty),2),float)
c=len(dados)/len(odinty)
for i in range(len(odinty)):
dif[i,0]=dados[c*i,0]
dif[i,1]=dados[c*i,1]-odinty[i,0]
return dif
dif4=diferenca(dados4)
dif3=diferenca(dados3)
dif2=diferenca(dados2)
dif1=diferenca(dados1)

37

Finalmente, usamos a funo plot para construir os dois grficos:

figure(1)
plot(t,odinty[:,0],'r',dados1[:,0],dados1[:,1],'b',dados
2[:,0],dados2[:,1],'y--',dados3[:,0],dados3[:,1],'g-',dados4[:,0],dados4[:,1],'r-',dados5[:,0],dados5[:,1],'b--')
xlabel("tempo")
ylabel("amplitude")
title("Comparacao dos integradores rk2 e odeint")
legend(('odeint h=0.2','rk2 h=0.02','rk2 h=0.05','rk2
h=0.1','rk2 h=0.2','rk2 h=0.5'))
figure(2)
plot(dif1[:,0],dif1[:,1],'b',dif2[:,0],dif2[:,1],'y',dif
3[:,0],dif3[:,1],'g',dif4[:,0],dif4[:,1],'r')
xlabel("tempo")
ylabel("diferenca")
title("Diferenca entre os integradores rk2 e odeint")
legend(('h=0.02','h=0.05','h=0.1','h=0.5'))
show()

38

7. Problema 7:
O integrador odeint tem uma maneira mais econmica que rk2 de agrupar os seus
argumentos: em vez de to, h e npoints , aceita uma lista de tempos como argumento. Refaa o
cdigo de rk2 para ter a mesma estrutura que odeint.
7.1.Introduo:
Neste problema -nos pedido para alterar a forma dos argumentos do integrador rk2 de forma a
ficar mais econmico e para que fique com a estrutura do integrador odeint. Ou seja, neste
problema vamos pr o integrador rk2 a funcionar com uma lista de valores t como argumento
ao invs dos argumentos to, h e npoints em que to era o tempo inicial, h o passo de integrao e
npoints o nmero de pontos em que queramos calcular a soluo.
7.2.Como passar os argumentos para a lista de valores t?
Vamos usar uma lista de tempos nos quais queremos calcular a soluo da equao diferencial.
No integrador rk2 o primeiro tempo considerado era to aquele em que sabamos a
soluo exacta da equao (a condio inicial que consideramos). Assim, o nosso primeiro
valor da lista t ser to.
Para isto teremos de transformar
recordar
ou seja:

o que se faz facilmente, bastando para isso

{
Assim temos que o primeiro h sempre to e os seguintes so calculados pelas diferenas dos
dois tempos anteriores, estes valores de h vo ser armazenadas na tabela a que chamaremos, t2.
Basta agora alterar o cdigo para uma indexao correcta, em que o primeiro ponto o
ponto soluo e os seguintes so aqueles em que queremos saber a soluo, assim basta
indexar estes valores por ordem na tabela.
def rk2(func,x0,t):
t2=[]
for i in range(len(t)):
if i==0:
t2.append(t[i])
else:
t2.append(t[i]-t[i-1])
traj=zeros((len(t),len(x0)+1),float)
for i in range(len(t)):
h=t2[i]
x0=rk2step(func,x0,h)
traj[i,0]=t[i]
traj[i,1:len(x0)+1]=x0
return traj

39

7.3.Testando o cdigo:
De modo a testar este cdigo, iremos utilizar a equao diferencial do Problema 1. Desta vez,
em vez de usarmos valores do tempo separados por um h, como no Problema 1, usamos uma
tabela de tempos, o que nos d mais liberdade de escolha. Definimos ainda a funo exct
com a soluo exacta para a equao como forma de comparao.
def f(v):
return -v
t=[0.0,0.1,0.2,0.21,0.22,0.221,0.222,0.223,0.225,0.3,0.4
,0.6,0.9,0.95,0.97,0.98,1.]
x0=array([[1.0]])
exct=zeros((len(t),2),float)
for i in range(len(t)):
exct[i,0]=t[i]
exct[i,1]=exp(-t[i])
rk2alt=rk2(f,x0,t)
A funo plot devolve-nos o seguinte grfico:

figure(1)
plot(exct[:,0],exct[:,1],'b',rk2alt[:,0],rk2alt[:,1],'ro')
xlabel('tempo')
ylabel('altura')
title('rk2alterado')
legend(('Exacto','rk2alterado'))
show()

40

7.4. Concluso:

Conseguimos alterar o cdigo de rk2 com sucesso e agora esta funo trabalha com os mesmos
argumentos da funo odeint.
Podemos agora dar o ponto soluo em qualquer ponto desde que saibamos o primeiro t (o t do
ponto soluo). Note-se contudo, que este mtodo depende do valor de h para fazer uma boa
aproximao. Por isso, no convm escolher pontos muito separados uns dos outros.
7.5.Anlise do cdigo:
Comeamos por importar os mdulos scipy, pylab e numpy, e definimos rk2step, o
passo do Mtodo de Runge-Kutta de ordem 2. Em seguida, definimos rk2 que comea por
criar uma nova lista com as diferenas entre os valores da lista de tempos inserida. Em seguida,
rk2 vai usar essa nova lista para criar uma tabela com os valores da funo nesses pontos.
from scipy import *
from pylab import *
from numpy import *
def rk2step (func,x0,h):
k0=func(x0)*h
return x0+func(x0+0.5*k0)*h
def rk2(func,x0,t):
t2=[]
for i in range(len(t)):
if i==0:
t2.append(t[i])
else:
t2.append(t[i]-t[i-1])
traj=zeros((len(t),len(x0)+1),float)
for i in range(len(t)):
h=t2[i]
x0=rk2step(func,x0,h)
traj[i,0]=t[i]
traj[i,1:len(x0)+1]=x0
return traj

41

Em seguida, para testar, inserimos uma lista t com os tempos onde queremos calcular a
soluo da equao o valor inicial x0 da funo, e definimos a funo f que a derivada da
funo.
t=[0.0,0.1,0.2,0.21,0.22,0.221,0.222,0.223,0.225,0.3,0
.4,0.6,0.9,0.95,0.97,0.98,1.]
x0=array([[1.0]])
def f(v):
return -v
rk2alt=rk2(f,x0,t)
Definimos ainda a soluo exacta para a equao:
exct=zeros((len(t),2),float)
for i in range(len(t)):
exct[i,0]=t[i]
exct[i,1]=exp(-t[i])
Finalmente, utilizamos a funo plot para desenhar o grfico:
figure(1)
plot(exct[:,0],exct[:,1],'b',rk2alt[:,0],rk2alt[:,1],'
r-o')
xlabel('tempo')
ylabel('altura')
title('rk2alterado')
legend(('Exacto','rk2alterado'))
show ( )

42