UNIVERSIDADE FEDERAL DE MATO GROSSO CAMPUS UNIVERSITÁRIO DO ARAGUAIA

INSTITUTO DE CIÊNCIAS EXATAS E DA TERRA

MESTRADO PROFISSIONAL EM ENSINO DE FÍSICA POLO BARRA DO GARÇAS

PRODUTO EDUCACIONAL

ESTUDO DE ÓRBITAS PLANETÁRIAS UTILIZANDO SIMULAÇÕES NUMÉRICAS COM PYTHON

DISCENTE: LUZINÊS NOVAIS DE ALMEIDA

ORIENTADOR: GEORGE BARBOSA DA SILVA

Barra do Garças

2016

UNIVERSIDADE FEDERAL DE MATO GROSSO

CAMPUS UNIVERSITÁRIO DO ARAGUAIA INSTITUTO DE CIÊNCIAS EXATAS E DA TERRA

MESTRADO PROFISSIONAL EM ENSINO DE FÍSICA POLO BARRA DO GARÇAS

PRODUTO EDUCACIONAL

Barra do Garças

2016

Sumário

INTRODUÇÃO................................................................................................. 4

APRESENTAÇÃO DO PRODUTO.................................................................. 5

EXPLICAÇÃO DO CÓDIGO A........................................................................ 10

EXPLICAÇÃO DO CÓDIGO B........................................................................ 18

PLANO DE AULA........................................................................................... 23

CONCLUSÃO ................................................................................................. 25

REFERENCIAS............................................................................................... 26

1. INTRODUÇÃO

Atualmente é possível lançar mão de inúmeros recursos didáticos, dentre

todas as opções podemos citar o uso das simulações prontas e também

daquelas que permitem ao professor programa-las. Este produto visa auxiliar o

professor de Física nas aulas de órbitas planetárias. Tendo em vista a linguagem

Python, a qual permite ao professor programar as suas próprias simulações

tornando-a compreensível aos seus alunos.

Tais conteúdos, quando apresentados com o uso exclusivo de

metodologias tradicionais, podem gerar desmotivação e desinteresse por parte

dos alunos, bloqueando o processo cognitivo no ensino aprendizado, e

prejudicando, dessa forma, a construção de novos conhecimentos. Portanto,

cabe aos professores, no papel de mediatizador, lançar mão de novos recursos

pedagógicos para tornar o ensino mais atrativo e interativo.

Dentre os diversos recursos de ensino, o computador vem se mostrando

uma ferramenta indispensável nas escolas, podendo ser utilizado no estudo de

inúmeros fenômenos da natureza através de simulações. Normalmente as

simulações voltadas para o ensino são inflexíveis e dão destaques somente a

um número limitado de detalhes do fenômeno estudado.

As simulações numéricas simples feitas em linguagem de alto nível, tal

como Python, merecem atenção especial dentro desse contexto dada a

facilidade de aplicação operação e modificação.

2. APRESENTAÇÃO DO PRODUTO

Nosso produto consiste em mostrar que é possível programar aulas de

Física para o ensino médio usando ferramentas computacionais simples e de

linguagem fácil. Todavia essa linguagem demanda, por parte do professor, uma

noção em programação. Dentre todas as linguagens de programação

disponíveis, o Python foi escolhido por ser uma linguagem simples e de fácil

acesso, já que nossa experiência em programação era básica, com

conhecimentos simples em computação.

Uma vez que você, professor de ensino médio, aprender o básico nesta

linguagem, poderá manusear vários códigos já prontos na rede de computadores

mundial “internet” ou ainda programar os seus para suas aulas.

Nosso produto relata a experiência feita na Escola Estadual Major Otavio

Pitaluga com alunos do ensino médio, o qual vem descrito na dissertação

disponível na internet.

Esse produto educacional é um conjunto de rotinas em Python, as

mesmas podem e devem ser usadas em orbitas keplerianas, isto é, forças

centrais que caem com o quadrado da distância A seguir apresentaremos

detalhadamente os códigos A e B construídos em Python e Vpython

respectivamente.

CÓDIGO A

#!/usr/bin/python # -*- coding: utf-8 -*- ##################################################################### # Nesta versão, o resultado final no gráfico # # será dado em coordenadas cartesianas (x,y). # # # # # # Note que o calculo é feito em coordenadas polares, # # mas o resultado é transformado para coordenadas cartesianas. # ##################################################################### # Primeiro, precisamos carregar os módulos from pylab import plot, show, ylim, xlim, xlabel, ylabel, grid, scatter, legend # Para converter os dados de coordenadas polares para cartesianas, # vamos precisar das funções seno e cosseno from math import cos, sin, pi # Vamos precisar da constante universal de gravitação. # Vamos usar a constante gravitacional heliocêntrica. k = 0.01720209395 GM = k**2 # Precisamos definir as condições iniciais. # As distâncias são dadas em UA e o tempo em dias. r = 1.0 theta = -pi/2 v = 0.008 omega = 2*pi/365.25 # O momento angular é uma constante de movimento L = omega*r*r # Podemos calcular também a energia mecânica total # Se E > 0, então a orbita será aberta # Se E < 0, a orbita será fechada Energia = 0.5*(v**2 + (L/r)**2) - GM/r # Para os gráficos em coordenadas cartesianas (x,y), # temos que preparar as listas x e y, # as quais são inicialmente vazias. x = [ ] y = [ ] # Definimos o passo de integração. dt = 0.01 # Para órbitas fechadas, basta percorrer uma volta.

theta_inicial = theta theta_final = theta_inicial + 2*pi # Por enquanto, o cálculo é para órbitas fechadas. if (Energia < 0): while(theta < theta_final): a = (L**2)/(r**3) - GM/(r**2) v = v + a*dt r = r + v*dt omega = L/r**2 theta = theta + omega*dt # Transformamos (r, theta) para (x,y) # e preenchemos as listas x e y. x.append(r*cos(theta)) y.append(r*sin(theta)) #Preparativos para o gráficos lim_max = max([max(x), max(y)]) lim_max = 1.10*lim_max # Para que a curva não toque a borda lim_min = -1*lim_max # Para que os eixos x e y tenham o mesmo tamanho ylim(lim_min, lim_max) xlim(lim_min, lim_max) xlabel("x (UA)") ylabel("y (UA)") plot(x,y, label = "Energia B") # Calculo analítico x = [] y = [] theta = 0 A = 1.0 epsilon = 0.01 print epsilon if (Energia < 0): while (theta < 2*pi): r = A/(1 + epsilon*cos(theta)) theta += 0.01 x.append(r*cos(theta)) y.append(r*sin(theta)) plot(x,y) # Podemos repetir os cálculos acima, porém com outros parâmetros iniciais # Condições iniciais (distâncias em UA e tempo em dias) # Para preservar Veff, muda-se somente a velocidade radial inicial. r = 1.0 theta = -pi/2

v = 0.0 omega = 2*pi/365.25 # Devemos cálcular L novamente se Veff for modificado. L = omega*r*r # Calculamos a energia mecânica novamente. Energia = 0.5*(v**2 + (L/r)**2) - GM/r # Preparamos as listas inicialmente vazias para as coordenadas x e y. x = [] y = [] # Passo de integração dt = 0.01 # E repetimos o cálculo percorrendo a trajetória fechada theta_inicial = theta theta_final = theta_inicial + 2*pi # Precisamos verificar se a órbita é fechada antes do loop. if (Energia < 0): while(theta < theta_final): a = (L**2)/(r**3) - GM/(r**2) v = v + a*dt r = r + v*dt omega = L/r**2 theta = theta + omega*dt # A seguir, transfomamos os dados em coordenas cartesianas # e acrescentamos as novas posições em x e e y. x.append(r*cos(theta)) y.append(r*sin(theta)) plot(x,y, label = "Energia A") # Colocamos o Sol no posição x = 0 e y = 0. scatter(0,0, s = 200, c = 'yellow', alpha = 0.8) legend(loc = 2) grid() show()

O nosso primeiro estudo, a título de exemplo, envolveu a comparação de

trajetórias em duas energias diferentes, denominadas por energia A e B, porém

mantendo o mesmo potencial efetivo. Para aumentar a energia mecânica do

sistema, sem alterar o potecial efetivo, deve-se alterar somente a velocidade

radial no instante inicial.

Abaixo apresentaremos os dois gráficos, os quais são resultados do

codigo A

Fig. 1 - Gráfico de trajetórias de planetas em duas condições de energias distintas,

porém com o mesmo potencial efetivo.

Fig. 2 - Gráfico potencial efetivo, gerado pela junção potencial gravitacional e energia centrípeta.

3. EXPLICAÇÃO DO CÓDIGO A

Construímos códigos em Python para resolver a cinemática dos planetas

com o objetivo de ajudar a compreensão dos alunos nos estudos de órbitas

planetárias. Além disso, com os códigos foi possível construir e discutir alguns

conceitos, tais como: momento angular, aceleração gravitacional, interação entre

os corpos, energia cinética e potencial gravitacional. Algumas linhas do código

foram explicitadas para os estudantes da Escola Estadual Major Otávio Pitaluga,

em Rondonópolis-MT, para que pudessem ter uma compreensão, mesmo que

elementar, sobre o funcionamento das rotinas de programação. Basicamente, os

alunos eram motivados a alterar as posições e velocidades iniciais e verificar

como as trajetórias eram alteradas.

A seguir, são mostradas as instruções em Python que usamos para o

nosso cálculo. Detalharemos cada linha de forma que fique explicita suas

funções e módulos.

A programação começa com as seguintes linhas:

>>> from pylab import plot, show, ylim, xlim, xlabel, ylabel, grid, scatter,

legend

>>>from math import cos, sin, pi

As duas linhas acima são comandos para importar os módulos das

bibliotecas pylab e math. A biblioteca pylab contém os módulos essenciais para

a construção de gráficos, enquanto que a biblioteca math contém os módulos

essenciais de cálculos científicos, tais como seno, cosseno, tangente, etc. Na

Tabela 1 mostramos a aplicação de cada um dos módulos da biblioteca pylab

usados no programa.

Tabela 1 – Módulos da biblioteca pylab usados na programação.

Módulos Aplicação Linha de comando

Python

Plot Esboça gráficos na figura a partir de duas listas de números de mesmo tamanho

plot(x,y, label = "Energia A")

Show Mostra a figura do gráfico em tela

show()

ylim, xlim Estabelece limite nos eixos y e x

ylim(-2.1, 2.1) xlim(-2.1, 2.1)

xlabel, ylabel

Estabelece a nomeclatura dos eixos

xlabel("x (UA)") ylabel("y (UA)")

Grid

Cria uma grade de linhas horizontais e verticais na figura para facilitar a leitura dos gráficos

grid()

Scatter Esboça pontos na figura scatter(0,0, s = 200, c = 'yellow', alpha = 0.8)

Legend Escreve a legenda dos gráficos na figura em uma posição determinada

legend(loc = 2)

Para o cálculo de trajetórias, usamos a constante gravitacional

heliocêntrica, que é produto da constante gravitacional universal pela massa do

Sol. Esta constante foi colocada em termos da constante gravitacional de Gauss

(k), sendo que GM = k2 ou k**2, como se escreve em linguagem de

programação.

>>> k = 0.01720209395

>>> GM = k**2

Usamos a unidade astronômica (UA) para distâncias, e dias para a

unidade de tempo. Uma unidade astronômica é a distância média entre a Terra

e Sol, isto é, aproximadamente 150 milhões de Km.

Em seguida atribuímos valores às posições inicias, isto é, no instante t =

0. As posições iniciais r(0), (0), �̇�(0) e �̇�(0), são representas nesta parte do

código por r, theta, v e omega, como é mostrado a seguir:

>>> r = 1.0

>>> theta = -pi/2

>>> v = 0.008

>>> omega = 2*pi/365.25

No código, as posições angulares são dadas em radianos. O valor acima

que foi atribuído para para �̇�(0) correponde ao valor médio da velocidade angular

da Terra, que gasta em torno de 365,25 dias para dar uma volta completa em

torno do Sol. Como a elipcidade da órbita da Terra é muito pequena, as

mudanças na velocidade angular são sutis.

Em seguida definimos as constantes do momento angular e energia

mecânica:

>>> L = omega*r*r

>>> Energia = 0.5*(v**2 + (L/r)**2) - GM/r

No cálculo, consideramos o momento angular e a energia mecânica como

constantes do movimento.

Para o gráfico em coordenadas cartesianas, criamos as listas:

>>> x = [ ]

>>> y = [ ]

Semelhantemente ao MATLAB, as listas x[ ] e y[ ], ou vetores na

linguagem de programação, são necessárias para criar os pares ordenados e

para esboçar os gráficos em coordenadas cartesianas. Elas são inicialmente,

criadas sem elementos, isto é, vazias. Apenas dentro do laço ocorrerá o seu

preenchimento, o que ocorrerá ponto a ponto. É bom lembrar que os cálculos

são feitos em coordenadas polares (r, theta), contudo, dentro do próprio laço,

que será explicado mais a frente, fizemos a transformação das coordenadas

para as cartesianas (x,y).

O intervalo de tempo precisa ser pequeno para que as aproximações pelo

método númerico de Euler sejam válidas. Assim atribuímos para t o valor de

0,01 dias.

>>> dt = 0.01

Valores menores que 0,01 dias poderiam dar maior precisão ao cálculo,

porém exigiria mais tempo de computação.

Limitamos o cálculo para a trajetória do planeta em uma volta completa.

Assim, determinamos que os ângulos variassem de 0 a 2𝜋 rad, dando limites às

posições angulares da seguinte forma:

>>> theta_inicial = theta

>>> theta_final = theta_inicial + 2*pi

Como desejamos fazer o cálculo somente de órbitas fechadas,

condicionamos a execução do cálculo à energia negativa da seguinte maneira:

>>> if (Energia < 0):

A função if impõe a condição para executar um comando posterior. O

bloco de comando que se encontra logo após o sinal de dois pontos será

executado somente se a energia mecânica for negativa. Esse critério é suficiente

para termos órbitas fechadas. É importante observar que os blocos de comandos

são marcados pela indentação.

Se a energia for negativa, então o cálculo de alguns pontos discretos de

r(t) e (t) ao longo da trajetória são realizados pelo seguinte laço de

programação:

>>> while(theta < theta_final):

>>> a = (L**2)/(r**3) - GM/(r**2)

>>> v = v + a*dt

>>> r = r + v*dt

>>> omega = L/r**2

>>> theta = theta + omega*dt

O laço serve para executar um conjunto de instruções, e continuará se

repetindo enquanto a condição dentro do comando while for verdadeira. Como

se observa, o cálculo por ele feito é o da trajetória do planeta em torno do Sol,

segundo o método de Euler, em aproximações sucessivas de primeira ordem.

Em instantes multiplos de t, isto é, para cada repetição do laço, o programa

realizará o cálculo de �̈�, �̇�, 𝑟, �̇�, e , os quais são representados pelas variáveis

a, v, r, omega e theta.

Ainda dentro do laço, preenchemos as listas x[ ] e y[ ] com o comando

append à medida que r e são calculados.

>>> x.append(r*cos(theta))

>>> y.append(r*sin(theta))

As transformações do par ordenado (r,) para as coordenadas

cartesianas são feitas diretamente dentro do comando append. Ao final de todas

as repetições do laço, isto é, quando a condição da função while deixar de ser

verdadeira, teremos os conjuntos de dados para as coordenadas x e y ao longo

de toda órbita do planeta.

As listas de dados x e y podem ser colocadas em forma de tabela que

pode ser armazenada em um arquivo. Assim o arquivo poderia ser utilizado por

qualquer outro programa especializado em gráficos científicos para a

representação da trajetória do planeta. No entanto, optamos por usar os recursos

do próprio Python através da biblioteca pylab para a confecção do gráfico. A

configuração do gráfico foi feita de acordo com os módulos apresentados na

Tabela 1. Uma vez configurados os limites do gráficos e legendas, o gráfico final

é obtido da seguinte maneira:

>>> plot(x,y, label = "Energia A")

>>> show()

CÓDIGO B

from visual.graph import *

from visual import *

# Para converter os dados de coordenadas polares para cartesianas

from math import sqrt, cos, sin, pi

# Vamos precisar da constante universal de gravitacao

# Vamos usar a constante gravitacional heliocentrica.

GM = 0.000295912036265

# Importante para o tamanho da tela da animacao

# Se nao definir o tamanho da tela, poderah haver atuozoon

def afelio(E, L):

delta = GM*GM + 2*E*L*L

return (-sqrt(delta) - GM)/(2*E)

# Precisamos definir as condicoes iniciais.

# As distancias sao dadas em UA e o tempo em dias.

r = 1.0

theta = -pi/2

v = 0.012

omega = 2*pi/365.25

# O momento angular eh uma constante de movimento

L = omega*r*r

# Podemos calcular tambem a energia mecanica total

# Se E > 0, entao a orbita serah aberta

# Se E < 0, a orbita serah fechada

Energia = 0.5*(v**2 + (L/r)**2) - GM/r

scene.y = 450

scene.x = 20

#scene.width = 1024

#scene.width = 760

#scene.center = (0,0,0)

f1 = gcurve(color = color.cyan)

f2 = gcurve(color = color.red)

f3 = gcurve(color = color.orange)

myWindow1 = gdisplay(xtitle = "tempo (dias)", ytitle = "Energia")

scene.title = "Orbitas de planetas"

# Colocamos o Sol no posicao x =0, y =0, e z = 0.

Sun = sphere(pos=(0,0,0), color = color.yellow, radius = 0.3,

material = materials.emissive)

Earth = sphere(pos=(r*cos(theta), r*sin(theta), 0), color =

color.black, radius = 0.1, make_trail = True)

# Definimos o passo de integracao.

dt = 0.01

# Por enquanto, o calculo eh para orbitas fechadas.

# Se a orbita eh fechada, entao pode-se calcular o afelio

# r_max eh usado para determinar o tamanho maximo da tela

# Evitando assim o autozoon

if (Energia < 0):

r_max = afelio(Energia, L)

# Vamos garantir que o tamanho da tela contenha a orbita

completa

Earth.pos.x = r_max

Earth.pos.x = -r_max

Earth.pos.y = r_max

Earth.pos.y = -r_max

else:

print "Verifique os valores iniciais para condicionar o calculo

para orbitas fechadas!"

exit()

scene.autoscaling = False

Earth.color = color.blue

Earth.trail = curve(color = color.green)

# O fator 0.6 que multiplica o tamanho do vetor eh arbitrario

Force = arrow(pos = Earth.pos, axis = (-0.6*Earth.pos/(r*r)), color

= color.red)

vx = v*cos(theta) - omega*r*sin(theta)

vy = v*sin(theta) + omega*r*cos(theta)

Velocidade = arrow(pos = Earth.pos, axis = (50*vx,50*vy,0), color =

color.white)

t = 0

while 1:

rate(1000)

a = (L**2)/(r**3) - GM/(r**2)

v = v + a*dt

r = r + v*dt

omega = L/r**2

theta = theta + omega*dt

#As posicoes do planeta sao atualizadas em cada iteracao

Earth.pos.x = r*cos(theta)

Earth.pos.y = r*sin(theta)

# O planeta deixa um rastro na animacao

Earth.trail.append(pos=Earth.pos)

# A seguir as coordenadas do vetor Force

Force.pos = Earth.pos

vx = v*cos(theta) - omega*r*sin(theta)

vy = v*sin(theta) + omega*r*cos(theta)

Velocidade.pos = Earth.pos

Velocidade.axis = (50*vx,50*vy,0)

Force.axis = -0.6*Earth.pos/(r*r)

#A seguir os graficos de energia sao atualizados

t += dt

K = 0.5*(v*v + r*r*omega*omega)

U = Energia - K

f1.plot(pos = (t, K), label = "Cinetica")

f2.plot(pos = (t, U), label = "Potencial")

f3.plot(pos = (t, Energia), label = "Total")

Abaixo apresentaremos os gráficos construídos com o código B feitos no

Vpython nas figuras 3, 4 e 5. Neste caso temos uma animação, a qual serve para

evidenciar os pontos afélio e periélio e sua velocidade, mudando ao longo da

trajetória. Enquanto na figura 5 temos um balanço das energias: mecânica em

amarelo; energia cinética na cor vermelha; e energia potencial gravitacional em

azul.

Fig. 3 – A figura a cima representa um corpo passado próximo ao periélio de sua órbita. A seta em vermelho (apontando para o Sol) representa a força, enquanto que a

seta em branco (tangente à trajetória) representa a velocidade do planeta.

Fig. 4 - A figura acima representa um corpo passando próximo ao seu afélio. A seta

em vermelho (apontando para o Sol) representa a força, enquanto que a seta em branco (tangente à trajetória) representa a velocidade do planeta.

Fig.5 - Gráficos de energia cinética, potencial e mecânica. A linha na cor azul corresponde à energia cinética. A linha na cor vermelha corresponde a energia

potencial e a linha na cor amarela, representa a energia total.

3.1 EXPLICAÇÃO DO CÓDIGO B

Mostraremos algumas instruções em Vpython usadas para a nossa

animação. Não detalharemos todo o código, uma vez que isso já foi feito no

código A, apenas mostraremos a detalhes entre os códigos em python (x,y) e

Vpython. Os códigos completos de programação em Vpython referente ao

estudo estão no Apêndice B. Em Vpython iniciamos assim:

>>> from visual.graph import *

>>> from visual import *

Para iniciarmos a programação em Vpython, faz-se necessário importar

da biblioteca visual os objetos e assim fazer rodar as animações. Já para

desenhar os gráficos, importamos a biblioteca Visual Graph.

Em Vpython é necessário definir os objetos. Na animação temos duas

esferas representando o Sol e a Terra (ou qualquer outro corpo celeste que

possui uma órbita kepleriana). Estabelecemos as posições, as cores, os raios e

a emissividade do material como segue:

>>> Sun = sphere (pos= (0,0,0), color = color.yellow, radius = 0.3, material =

materials.emissive)

>>> Earth = sphere (pos=(r*cos (theta), r*sin (theta), 0), color = color.black,

radius = 0.1, make_trail = True)

Definimos o afélio, isto é, o ponto mais longe possível do planeta em

relação ao Sol, cuidando para que a animação não saia do campo visual e nem

aconteça um auto zoom. Isso por sua vez pode diminuir o tamanho proporcional

da imagem do Sol em nossa animação.

>>> def afelio (E, L):

>>> delta = GM*GM + 2*E*L*L

>>> return (-sqrt(delta) - GM)/(2*E)

Uma vez definido o afélio, é possível definir os limites do quadro que irá

contemplar a animação da órbita. Nesta animação, o Sol é colocado no centro

do quadro. Tanto o tamanho vertical do quadro, quanto o horizontal, são

determinados pelo afélio.

>>> if (Energia < 0):

r_max = afelio(Energia, L)

Earth.pos.x = r_max

Earth.pos.x = -r_max

Earth.pos.y = r_max

Earth.pos.y = -r_max

>>>else:

print ()

exit ()

Assim que o tamanho do quadro é estabelecido, é necessário que a

função de auto escala seja desligada para que possamos visualizar toda a

animação nas proporções definidas.

>>> scene.autoscale = False

Definimos também a cor do planeta Terra e de seu rastro.

>>> Earth.color = color.blue

>>> Earth.trail = curve(color = color.green)

Em seguida, definimos os vetores força e velocidade. O vetor força estará

na direção radial, apontando sempre para o Sol. A sua intensidade varia em

proporção a aceleração do planeta.

>>> Force = arrow(pos = Earth.pos, axis = (-0.6*Earth.pos/(r*r)), color =

color.red)

O vetor velocidade será sempre tangente à trajetória.

>>> vx = v* cos (theta) – ômega * r * sin (theta)

>>> vy = v* sin (theta) + ômega * r * cos (theta)

>>>Velocidade = arrow ( pos = Earth.pos, axis = ( 50* vy, 0) , color =

color.white)

O vetor velocidade é colocada sobre o planeta e é atualizado ao longo da

trajetória, ou seja, o vetor é atualizado dentro do laço de programação em que

se calcula a trajetória. Este cálculo é feito com muita semelhança ao que foi feito

anteriormente. Por se tratar de uma animação, o cálculo não é limitado à

trajetória de uma volta apenas.

>>> while 1:

rate(10000)

a = (L**2)/(r**3) - GM/(r**2)

v = v + a*dt

r = r + v*dt

omega = L/r**2

theta = theta + omega*dt

O rastro do planeta é definido com a seguinte função:

>>> Earth.trail.append(pos=Earth.pos)

Para o estudo da energia mecânica, construímos os gráficos de energia

total, cinética e potencial em função do tempo. Os atributos das linhas foram

definidas antes do laço.

>>> t += dt

>>> K = 0.5*(v*v + r*r*omega*omega)

>>> U = Energia - K

>>> f1.plot(pos = (t, K), label = "Cinetica")

>>> f2.plot(pos = (t, U), label = "Potencial")

>>> f3.plot(pos = (t, Energia), label = "Total")

Há muito outros detalhes que podem ser contemplados no código

completo que se encontra no apêndice B.

Nosso trabalho foi desenvolvido na Escola Estadual Major Otavio Pitaluga

e foram ofertadas vagas aos alunos do segundo ano do ensino médio para que

participassem. Fizemos o trabalho em dois momentos: o primeiro na sala de

informática e o segundo nas salas de aula. Na sala de informática tivemos

somente alunos do segundo ano, mas de turmas diferentes. Para eles colocamos

a ideia do projeto, a qual era debater órbitas planetárias com o auxílio de uma

ferramenta computacional. Explicamos os conceitos físicos envolvidos e como

as simulação numérica em Python e animação em Vpython poderiam ajudar na

compreensão das órbitas planetárias, a qual foi discutida na seção 2.5.

No laboratório de informática trabalhamos com um computador por aluno.

Trabalhamos inicialmente com dezenove alunos, que receberam o código fonte

já pronto, com o objetivo de aprender a rodar o programa e, em seguida, realizar

mudanças nas variáveis de velocidade inicial e posição. Com essas alterações

foi possível órbitas des diferentes elipticidades, além de visualizar as trajetórias

em Python (x,y).

As animações em Vpython foram usadas em um segundo momento, em

sala de aula, envolvendo as turmas B, C, E e F do segundo ano, totalizando 115

alunos. Com esses, usamos as animações e explicamos os conceitos físicos

envolvidos. O foco principal do nosso trabalho foi a mudança na velocidade do

planeta relacionada com a energia cinética e a potencial gravitacional,

mostrando como os pontos do periélio e afélio estão associadas com energia

potencial mínima e máxima, respectivamente.

4. Plano de Aula

Órbitas Planetárias

A seguir é apresentado o planejamento das aulas ministradas. As mesmas

foram realizadas na Escola Estadual Major Otávio Pitaluga com os alunos do 2º

ano do ensino médio.

Objetivos

Conceituar órbitas planetárias;

Definir os pontos afélio e periélio;

Enunciar as leis de Kepler;

Relacionar as Leis de Kepler com a Lei da Gravitação Universal;

Mostrar balanço energético ao longo da trajetória do planeta;

Mostrar o comportamento de velocidade ao longo da trajetória do planeta,

partindo de análises no simulador em VPython.

Recursos Didáticos

Computador

Rotinas de programa em Python

Desenvolvimento

As aulas realizadas em sala retomarão os conteúdos de movimentos de

translação, indagando sobre questões como: O que é órbita de um planeta?

Como um computar poderia nos auxiliar? Satélites artificiais possibilitam as

comunicações e seus benefícios são claros no nosso dia a dia? Além da nossa

Lua quem tem sua órbita atendendo a lei da gravitação universal? Relacionando

a Leis de Kepler mostraremos que as órbitas planetárias descrevem uma elipse.

As aulas realizadas no laboratório de informática mostrarão os benefícios

do simulador para explicar os pontos afélio e periélio. Utilizaremos a

programação em Python que permite observar as órbitas e as velocidades, bem

como relacionar a energia cinética (velocidade) com o potencial gravitacional. Na

programação testaremos as velocidades na órbita mudando apenas a

velocidade inicial levando-os a observar o que acontecerá com as trajetórias.

Durante as aulas os alunos serão estimulados com perguntas e repostas que

agucem a curiosidade deles. Por exemplo: a mudança da velocidade inicial

influencia na trajetória? Qual é a relação entre energia cinética e potencial

gravitacional? Como podemos explicar isso observando a Lei da Gravitação

Universal?

Explicaremos que há um ponto na órbita chamado de afélio e outro de

periélio. Iremos relacionar alguns destes detalhes com os estudos de Kepler.

Discutiremos essas questões com os alunos enquanto exploramos as

animações em VPython.

Avaliação

A avaliação terá caráter diagnóstico e formativo, pois com o auxílio de

questionários e conversas será possível compreender os subsunçores

(conhecimento prévio) que cada aluno possui sobre o conteúdo e, no decorrer

de cada aula, através da participação dos alunos e dos relatos escritos, avaliar

o que foi de fato assimilado durante as aulas. Outro indicador de conhecimento

adquirido será o desempenho de cada um nas olimpíadas de astronomia OBA

Referências

PYTHON. Disponível em: https://www.python.org/ > Consultado em 2015. STEFANOVTS, Angelo. Ser protagonista: Física: 1° ano ensino médio. 2. ed. São Paulo: Edições SM, 2013. VPYTHON Disponível em: http://vpython.org/contents/download_windows.html > consultado 2014.

.

5. CONCLUSÃO

Caro professor, o uso desse produto facilitará a visualização dos pontos

afélio e periélio bem como a animação das órbitas planetárias contribuindo assim

para compreensão da energia potencial gravitacional contrapondo com energia

cinética.

A aplicação da simulação ajudou na contextualização das órbitas

planetárias. O método didático usado mostrou que lançar mão de recursos da

computação nas aulas facilita a visualização do fenômeno em questão. No

entanto, enquanto educadores, precisamos evoluir no processo ensino e

aprendizagem e na construção dos conceitos físicos inerente a órbitas

planetárias. Porém cada professor é dono do seu método de ensino. Lógico que,

cada um poderá fazer as mudanças necessárias nesse produto para adapta-lo

a sua metodologia de ensino.

O ensino de física tem muitos desafios, um deles é introduzir a tecnologia

no processo ensino e aprendizagem. Esse trabalho teve como objetivo criar uma

ferramenta para auxiliar o professor no conteúdo de órbitas planetárias, uma vez

que a visualização e modelagem é facilitada com o uso animações.

6. REFERÊNCIAS

______. Ministério da Educação, Secretaria de Educação Média e tecnológica.

Parâmetros Curriculares Nacionais: Ensino Médio. Brasília: Ministério da

Educação, 2002.

MEDEIROS, Alexandre. & MEDEIROS, C.F. Possibilidades e limitações das

simulações computacionais no ensino de física. Revista Brasileira de Ensino

de Física, Recife, v. 24, n. 2, p. 77-86, junho 2002.

PYTHON. Disponível em: https://www.python.org/ > Consultado em 2014. PYTHON(X,Y).Disponível em: https://python-xy.github.io/downloads.html > Consultado em 2014. SOUZA, Fabrício Araújo de. Levantamento e análise de softwares livres de

Física para o Ensino Médio. Porto Velho, 2012.

VPYTHON Disponível em: http://vpython.org/contents/download_windows.html > consultado 2014.