Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Download

Jupyter notebook Periodo orbital de los satélites artificiales.ipynb

3024 views
Tweet
Share
Share
Kernel: Python 2

Proyecto

Profesor: Alejandro Villareal López

Alumno: Alberto Tlanextli Santiago Lara

Periodo orbital satelital

Este programa nos ayudará a calcular el tiempo que demora un satélite artificial en orbitar un cuerpo celeste

Para calcular el periodo antes debemos tomar en cuenta algunos datos adicionales:

Tamaño de la orbita: Nos dice cómo de grande es una órbita. Este parámetro depende de la velocidad con la que lancemos nuestro satélite a la órbita. Cuanto más rápido realicemos la inyección, más energía tiene la órbita y mayor es. Se expresa el tamaño orbital en términos de su semi-eje mayor. El eje mayor de una órbita elíptica es la distancia desde del punto más cercano (perigeo) y el más alejado (apogeo). Debido al principio de la conservación de la energía, en una órbita elíptica, la velocidad del satélite es mayor en el perigeo que en el apogeo

Semi-eje mayor: Podemos expresar el semieje mayor en términos de la distancia desde el centro dela Tierra hasta el apogeo (Rapogeo) y el perigeo (Rperigeo). El semieje mayor (alfa) puede obtenerse aplicando:

                               alfa=Rapogeo+Rperigeo/2

El período orbital T (es decir, cuánto tiempo tarda el satélite en describir una órbita completa), es proporcional al tamaño de la órbita y viene dado por la siguiente expresión:

T2=4π2(RT+α)3GMTT^2 = \frac{4\pi^2 (R_T + \alpha)^3}{G M_T}

Donde: #RT= radio de la Tierra= 6.38E6m #G= constante de gravitación universal=6.67E-11N m²/Kg² #MT= masa de la Tierra= 5.98E24Kg #alfa= semi-eje mayor de la órbita que depende del satélite del que queramos calcular su periodo

Para llegar a esta ecuación sólo tenemos que basarnos en las leyes de Kepler, tomar en cuenta la fuerza de atracción gravitacional de la Tierra, igualarlas y despejarlas en ecuaciones mas simples hasta llegar a los valores que necesitamos para calcular el periodo orbital.

Primero tomamos:

F = m*g

Como F es la fuerza de atracción gravitatoria:

G (M m / R²) = m (v² / R)

Simplificando las masas y los radios, tenemos:

G (M / R) = v²

Pero la velocidad tangencial es igual a la angular por el radio de giro, es decir:

v = ω R

Sustituyendo:

G (M / R) = (ω R)²

Ahora bien, la velocidad angular es igual a:

ω = 2π / T

Volviendo a sustituir:

G (M / R) = (2π / T)² R² → G M / R³ = 4π² / T² → G M T² = 4π² R³

T² = 4π² R³ / G M

Como, en este caso, R = RT + alfa, sustituyendo obtenemos la siguiente expresión:

T² = 4π² (RT + alfa)³ / G M

Al final como el resultante nos da en segundos aplicamos la conversión del tiempo para reducir el valor y obtenerlo en términos mas simples.

T en min. = T²= (4π² (RT + alfa)³ / G M)/60

Ahora para probar esta ecuación vamos a resolver un problema tomando en cuenta la Estación Espacial Internacional

Ejemplo

Programa un algoritmo que calcule el periodo orbital que demora un satélite en orbitar la Tierra, introduciendo un alfa por teclado. En este caso calcula el periodo orbital de la ISS. Compaándola con el periodo de la Estación Espacial Rusa

  ISS

#Perigeo= 400Km #Apogeo= 408km

Estación Espacial Rusa

#Perigeo= 386km #Apogeo= 398km

from pylab import linspace, pi
%matplotlib inline


from numpy import sqrt
T=1
RT=6.38E6
G=6.67E-11
M=5.98E24
RaI= int(input('Introduce el valor del apogeo: '))
RpI= int(input('Introduce el valor del perigeo: '))
alfa1= (RaI+RpI)/2
print alfa1
Introduce el valor del apogeo: 408000 Introduce el valor del perigeo: 400000 404000 
T1=sqrt((4*pi**2*(RT+alfa1)**3)/(G*M))/60
print T1
92.6496681033 
RaR= int(input('Introduce el valor del apogeo: '))
RpR= int(input('Introduce el valor del perigeo: '))
alfa2= (RaR+RpR)/2
print alfa2
Introduce el valor del apogeo: 398000 Introduce el valor del perigeo: 386000 392000 
T2=sqrt((4*pi**2*(RT+alfa2)**3)/(G*M))/60
print T2
92.4039493053 
import numpy as np
import matplotlib.pyplot as plt
font_size=10
alfa=np.arange(392000,404000,100.0)
T=sqrt((4*pi**2*(RT+alfa)**3)/(G*M))/60
plt.plot(alfa, T)
plt.xlabel(r'Incremento del semieje mayor de la Mir a la ISS $(m)$', fontsize=font_size)
plt.ylabel('Periodo $(min)$', fontsize=font_size)
plt.title('Periodo orbital', fontsize=font_size)
<matplotlib.text.Text at 0x7f9586fd5450>
Image in a Jupyter notebook
"""
An animated image demonstrating circular motion
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from JSAnimation import IPython_display

#generate a figure onto which our animation will be plotted
fig = plt.figure()
#add a subplot to this figure
#"111" means generate a 1x1 grid of plots, and this subplot goes in the 1st available grid space
#the returned variable is a representation of the axes of the subplot (hence ax)
ax = fig.add_subplot(111, xlim=(-6, 6), ylim=(-1.5, 1.5))
#prepare the line variable by assigning it to an empty line on these axes
#'o-' means plot points as circles (o) and connect them with solid lines (-)
line, = ax.plot([], [], 'o', markersize=20)

#first we define an initialisation function for our line
def init():
    #set the data to [], [] for the x, y coordinates, respectively
    line.set_data([], [])
    return line

#now we define a function which will animate the line forward one step
def animate(i):
    #first generate an angle in radians
    angle = i/20. * np.pi
    #now set the coordinates of the points along the line to [0,0] and [cos(angle), sin(angle)]
    thisx = [0, np.cos(angle)]
    thisy = [0, np.sin(angle)]
    #set the x, y coordinates to these new values
    line.set_data(thisx, thisy)
    return line

#generate the animation using animation.FuncAnimation
#inputs are: fig, the figure we'll plot to; animate, the animation function to use;
#np.arange(1,100); the series of inputs used to generate each animation frame;
#interval, the time between frames in miliseconds;
#init_func, the name of the initialisation function for our animated object
animation.FuncAnimation(fig, animate, np.arange(1, 100), interval=50, init_func=init)