Upload
others
View
2
Download
0
Embed Size (px)
Citation preview
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.