def test_crear_planeta_angulo_limite_ok(self):
Planeta(nombre="Tierra", angulo=-360, distancia=100,
velocidad=1, sentido=1)
Planeta(nombre="Tierra", angulo=0, distancia=100,
velocidad=1, sentido=1)
Planeta(nombre="Tierra", angulo=360, distancia=100,
velocidad=1, sentido=1)
def init_queue(self):
for i in range(10):
new = Enemy()
self.enemy_queue.push(new)
for i in range(10):
new = Asteroide()
self.asteroid_queue.push(new)
for i in range(50):
new = Shoot()
self.bullets_queue.push(new)
for i in range(3):
new = Flor()
self.flowers_queue.push(new)
for i in range(5):
new = Planeta()
self.planets_queue.push(new)
for i in range(21):
new = Explode()
self.explosion_queue.push(new)
for i in range(11):
new = Propellant()
self.propellant_queue.push(new)
def init_queue(self):
for i in range(20):
new = Enemy()
self.enemy_queue.push(new)
for i in range(50):
new = Asteroide()
self.asteroid_queue.push(new)
for i in range(100):
new = Shoot()
self.bullets_queue.push(new)
for i in range(10):
new = Planeta()
self.planets_queue.push(new)
for i in range(50):
new = Explode()
self.explosion_queue.push(new)
for i in range(30):
new = Propellant()
self.propellant_queue.push(new)
for i in range(20):
new = Power_up()
self.power_queue.push(new)
def crear_planeta(self):
print("Ingrese nombre del planeta (largo mínimo 6): ", end="")
nombre = fu.pedir_string(6)
while nombre in Galaxia.planetas:
print("Ya existe un planeta con este nombre en alguna galaxia",
"ingrese nuevamente: ",
end="")
nombre = fu.pedir_string(6)
n_raza = fe.pedir_raza()
raza = None
if n_raza == 1:
raza = cl.Aprendiz()
elif n_raza == 2:
raza = cl.Maestro()
elif n_raza == 3:
raza = cl.Asesino()
nuevo_planeta = Planeta(raza)
cantidad_a_poblar = (nuevo_planeta.capacidad * 0.75) // 1
nuevo_planeta.soldados = int(cantidad_a_poblar)
self.planetas[nombre] = nuevo_planeta
Galaxia.planetas[nombre] = (nuevo_planeta, self.nombre)
def cargar_data(dia_inicio):
planetas = []
for record in cargar_planetas():
planetas.append(
Planeta(record.nombre, record.angulo, record.distancia,
record.velocidad, record.sentido))
sistema = SistemaSolar(planetas=planetas, dia=dia_inicio)
min_vel = db.planeta.velocidad.min()
min_vel = db(db.planeta.id > 0).select(min_vel).first()[min_vel]
diasporanio = VUELTA_AL_SOL // min_vel
for i in range(0, diasporanio * ANIOS_PRONOSTICO):
data = sistema.do_step()
db.clima_registro.insert(dia=data['dia'], clima=data['estado'])
for planeta in sistema.planetas:
db.planeta_posicion.insert(dia=sistema.dia, **planeta.__dict__())
pronostico = sistema.pronostico_clima()
db.clima_estadistica.truncate()
for k, v in pronostico.items():
db.clima_estadistica.insert(clima=k, valor=v)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Complete el código a continuación.
'''
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
condicion_inicial = [10, 0, 0, 0.3]
Jupiter = Planeta(condicion_inicial)
t_final = 1025.
numero_pasos = 10000
dt= t_final / (float)(numero_pasos)
t_values = np.linspace(0,t_final,numero_pasos)
x = np.zeros(numero_pasos)
y = np.zeros(numero_pasos)
vx = np.zeros(numero_pasos)
vy = np.zeros(numero_pasos)
energia = np.zeros(numero_pasos)
[x[0],y[0],vx[0],vy[0]] = condicion_inicial
energia[0] = Jupiter.energia_total()
for i in range (1,numero_pasos):
#pdb.set_trace()
Jupiter.avanza_euler(dt)
resultados = Jupiter.y_actual
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
condicion_inicial = [10, 0, 0, 0.3]
Jupiter = Planeta(condicion_inicial)
x_value = []
y_value = []
E = []
dt=0.1
pasos=10500
t_values = np.array(range(pasos))*dt
for i in range(pasos):
x_value.append(Jupiter.y_actual[0])
y_value.append(Jupiter.y_actual[1])
E.append(Jupiter.energia_total())
Jupiter.avanza_rk4(dt)
x_value = np.array(x_value)
y_value = np.array(y_value)
energia = np.array(E)
print energia
fig=plt.figure(1)
plt.subplot(2, 1, 1)
fig.subplots_adjust(hspace=.5)
plt.plot(x_value , y_value)
nuevo_planeta = {}
for line in planetas_file:
datos_planeta = (dato.strip() for dato in
line.strip("\n").split(","))
for dato in orden:
nuevo_planeta[dato] = datos_planeta.__next__()
if nuevo_planeta["raza"] == "Aprendiz":
raza = Aprendiz()
elif nuevo_planeta["raza"] == "Maestro":
raza = Maestro()
elif nuevo_planeta["raza"] == "Asesino":
raza = Asesino()
else:
raise ValueError
galaxia = game.galaxias[nuevo_planeta["galaxia"]]
galaxia.planetas[nuevo_planeta["nombre"]] = Planeta(raza)
planeta = galaxia.planetas[nuevo_planeta["nombre"]]
planeta.magos = int(nuevo_planeta["magos"])
planeta.soldados = int(nuevo_planeta["soldados"])
planeta.tasa_minerales = int(nuevo_planeta["tasa_minerales"])
planeta.tasa_deuterio = int(nuevo_planeta["tasa_deuterio"])
planeta.nivel_ataque = int(nuevo_planeta["nivel_ataque"])
planeta.nivel_economia = int(nuevo_planeta["nivel_economia"])
if nuevo_planeta["conquistado"] == "True":
planeta.conquistado = True
galaxia.planetas_conquistados.add(nuevo_planeta["nombre"])
if nuevo_planeta["torre"] == "True":
planeta.torre = Edificio(150, 300, 1000, 2000)
if nuevo_planeta["cuartel"] == "True":
planeta.cuartel = Edificio(200, 500, 0, 5000)
recoleccion = nuevo_planeta["ultima_recoleccion"]
from planeta import Planeta import numpy as np import matplotlib.pyplot as plt ''' CI = condiciones iniciales, tal que: x_0 = 10 y_0 = 0 vx_0 = 0 vy_0 libre ''' # - - - Solucion usando Euler - - - # CI = np.array([10., 0, 0, 0.35]) p = Planeta(CI) t_total = 1000. N = 1000 t_paso= t_total/N x = np.zeros(N); y = np.zeros(N) vx = np.zeros(N); vy = np.zeros(N) E = np.zeros(N) [x[0],y[0],vx[0],vy[0]] = CI E[0] = p.energia_total() t= np.linspace(1,t_total,N)
'''
Este script utiliza la clase Planeta para resolver la órbita de un planeta de
masa 1 kg, orbitando un cuerpo central de masa M = 1.498 x 10^10 kg. El
movimiento es determinado usando el método de Euler explícito. Al final se
presentan los resultados en forma de gráficos de la órbita y de la energía en
el tiempo.
'''
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
#Solucion a trayectoria
condicion_inicial = [10.0, 0.0, 0.0, 0.3]
Mars = Planeta(condicion_inicial)
x_pos = []
y_pos = []
energia = []
dt=0.1
for i in range(10000):
x_pos.append(Mars.y_actual[0])
y_pos.append(Mars.y_actual[1])
energia.append(Mars.energia_total())
Mars.avanza_euler(dt)
x_pos = np.array(x_pos)
y_pos = np.array(y_pos)
energia = np.array(energia)
#Resultados
#!/usr/bin/env python # -*- coding: utf-8 -*- from planeta import Planeta import pdb import numpy as np import matplotlib.pyplot as plt VY0=0.3 condicion_inicial = np.array([10., 0, 0, VY0]) p = Planeta(condicion_inicial) t_final = 3000. numero_pasos = 2000+1 dt= t_final / (float)(numero_pasos) x = np.zeros(numero_pasos) y = np.zeros(numero_pasos) vx = np.zeros(numero_pasos) vy = np.zeros(numero_pasos) energia = np.zeros(numero_pasos) [x[0],y[0],vx[0],vy[0]] = condicion_inicial energia[0] = p.energia_total() p.avanza_rk4(dt) resultados = p.y_actual x[1] = resultados[0] y[1] = resultados[1] vx[1] = resultados[2] vy[1] = resultados[3]
def test_crear_planeta_distancia_negativa_ok(self):
Planeta(nombre="Tierra", angulo=0, distancia=-100,
velocidad=1, sentido=1)
peri_y = np.array([])
for i in range(len(x) - 2):
if x[i + 1]**2 + y[i + 1]**2 >= x[i]**2 + y[i]**2:
if x[i + 1]**2 + y[i + 1]**2 >= x[i + 2]**2 + y[i + 2]**2:
peri_x = np.append(peri_x, x[i + 1])
peri_y = np.append(peri_y, y[i + 1])
return peri_x, peri_y
#condiciones iniciales
vyo = 0.4 #0.4 para euler y rk4 0.05 para verlet
condicion_inicial = [10., 0., 0., vyo]
alpha = 10**(-2.231) #231 ultimos 3 digitos antes de verificador
p = Planeta(condicion_inicial,
alpha) #agregar o quitar alpha para los casos 2 y 3
#se definen variables a usar
n = 1000000 #numero de pasos a realizar #10000 sin alpha....100000 con alpha verlet
# 1000000 con alpha euler y rk4
t = np.zeros(n) #genera vector tiempo a completar
dt = 0.05 #tamanho del paso
x = np.zeros(n) #genera vector posicion x a completar
y = np.zeros(n) #genera vector posicion y a completar
E = np.zeros(n) #genera vector energia total a completar
#se completan las variables para graficar
x, y, t, E = ec_mov(p, t, dt)
peri_x, peri_y = perihelio(x, y)
print 'n orbitas =', len(peri_x) #identifica numero de orbitaciones
Este script utiliza la clase Planeta para resolver la órbita de un planeta de
masa 1 kg, orbitando un cuerpo central de masa M = 1.498 x 10^10 kg. El
movimiento es determinado usando el método de Verlet. En este script se añade
el parámetro correspondiente a la corrección relativista para órbitas cercanas
al cuerpo central. Al final se presentan los resultados en forma de gráficos de
la órbita y de la energía en el tiempo.
'''
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
#Solucion a trayectoria
condicion_inicial = [10.0, 0.0, 0.0, 0.3]
Mercury = Planeta(condicion_inicial,10**(-2.350))
x_pos = [Mercury.y_actual[0]]
y_pos = [Mercury.y_actual[1]]
energia = [Mercury.energia_total()]
dt=0.01
Mercury.avanza_rk4(dt)
for i in range(600000):
x_pos.append(Mercury.y_actual[0])
y_pos.append(Mercury.y_actual[1])
energia.append(Mercury.energia_total())
Mercury.avanza_verlet(dt)
x_pos = np.array(x_pos)
y_pos = np.array(y_pos)
energia = np.array(energia)
#!/usr/bin/env python # -*- coding: utf-8 -*- from planeta import Planeta import numpy as np import matplotlib.pyplot as plt condicion_inicial = [10, 0, 0, 0.4] p = Planeta(condicion_inicial) dt = 0.1 iteraciones = 60000 x = np.zeros(iteraciones) y = np.zeros(iteraciones) vx = np.zeros(iteraciones) vy = np.zeros(iteraciones) energia = np.zeros(iteraciones) tiempo = np.zeros(iteraciones) x[0] = p.y_actual[0] y[0] = p.y_actual[1] energia[0] = p.energia_total() tiempo[0] = p.t_actual vx[0] = p.y_actual[2] vy[0] = p.y_actual[3] #Verlet necesita una iteracion extra p.avanza_rk4(dt) x[1] = p.y_actual[0]
'''=========================================================
@Autor: Rodrigo Barreto
Objetivo: Módulo criado para testar as funções
do módulo Planeta
========================================================='''
from planeta import Planeta
import json
import planeta as pl
# Teste 1: Listando todos os planetas
p = Planeta()
print("=====================================")
print("Teste 1: Listando todos os planetas:")
print()
pl.showAllPLanets(p)
# Teste 2: Buscando um planeta por nome
print("=====================================")
print("Teste 2: Buscando um planeta por nome")
print("")
namePlanet = "Yavin IV"
planet = pl.getPlanetByName(p, namePlanet)
pl.showPlanet(planet)
print("")
# -*- coding: utf-8 -*-
'''
Script que utiliza Runge_kutta 4 para calcular y graficar aproximadamente
5 orbitas. Además grafica energia vs tiempo.
'''
import numpy as np
import matplotlib.pyplot as plt
from planeta import Planeta
condicion_inicial = [10, 0, 0, 0.3] #x, y, vx, vy
p = Planeta(condicion_inicial) #se establece condicio inicial como actuales
t_total=900 #aproximadamente 5 orbitas
# se crean listas vacias de x, y, Energia
x=[]
y=[]
Energia=[]
#Se agregan condiciones iniciales
x.append(condicion_inicial[0])
y.append(condicion_inicial[1])
Energia.append(p.energia_total())
dt=1
t=1 #ya se realizo el primer calculo
while t<=t_total:
p.avanza_rk4(dt)
xf, yf, vxf, vyf = p.y_actual
x.append(xf)
y.append(yf)
def orbitar(CI, solucion, prt=True):
'''
Esta función es cool, porque le entregas las condiciones iniciales (CI)
en forma de x0,y0,vx0,vy0, además de un string con el tipo de solución
que quieres, como 'euler', 'rk4' o 'verlet' y nos devuelve las coordenadas
x,y y la energia total del planeta. Además de un ploteo de la órbita, apropi-
adamente labelado y un ploteo de la energía vs el tiempo.
La ultima parte es para que plotee, el valor default es que
plotee (true or false).
Ejemplo de uso:
orbitar([10,0,0,0.1],'verlet')
x=[0,0.1,...]
y=[0,0.3,...]
energia=[7,8,...]
'''
if solucion == 'euler':
n = 2500 #grande y dsps se arregla
if solucion == 'rk4':
n = 5000 #grande y dsps se arregla
if solucion == 'verlet':
n = 800
Aiur = Planeta(CI) #se crea el planeta
if solucion == 'verlet_reloaded': #caso especial para la ultima parte
n = 6000
Aiur = Planeta(CI, alpha=alpha2) #si es el verlet bkn se parcha
dt = 1 #error si es muy chico
tmax = n * dt
x = [] #listas vacias a llenar
y = []
pylon = [] #energia
x = np.append(x, CI[0]) #llenamos con el primer termino
y = np.append(y, CI[1])
pylon = np.append(pylon, Aiur.energia_total())
for i in range(tmax): #aca se hace la iteracion del paso
if solucion == 'euler':
Aiur.avanza_euler(dt)
if solucion == 'rk4':
Aiur.avanza_rk4(dt)
if solucion == 'verlet' or solucion == 'verlet_reloaded':
Aiur.avanza_verlet(dt)
xn, yn, vxn, vyn = Aiur.y_now
x = np.append(x, xn)
y = np.append(y, yn)
pylon = np.append(pylon, Aiur.energia_total())
times = np.linspace(0, tmax, tmax + 1)
if prt == True:
fig1 = plt.figure(1) #aca se plotea, muy standar
fig1.clf()
if solucion == 'euler':
plt.plot(x, y, 'r', label='Trayectoria metodo Euler')
plt.title('Trayectoria metodo Euler')
if solucion == 'rk4':
plt.plot(x, y, 'r', label='Trayectoria metodo RK4')
plt.title('Trayectoria metodo RK4')
if solucion == 'verlet' or solucion == 'verlet_reloaded':
plt.plot(x, y, 'r', label='Trayectoria metodo Verlet')
plt.title('Trayectoria metodo Verlet')
plt.xlabel('X')
plt.ylabel('Y')
plt.savefig('verlet_rld.png')
plt.draw()
plt.show()
fig2 = plt.figure(2)
fig2.clf()
plt.plot(times, pylon, 'g')
plt.xlabel('Tiempo')
plt.ylabel('Energia')
plt.title('Tiempo vs Energia')
plt.savefig('verlet_rld_energia.png')
plt.draw()
plt.show()
return x, y, pylon
import matplotlib.pyplot as plt import scipy as sp from planeta import Planeta import scipy.stats import numpy as np ''' PARTE3 Ahora considero el caso alfa no cero, mi rut es 189563752 y se usara verletvelocity para integrar la ecuacion de movimiento. Luego se determinara la posicion del perihelio y la velocidad angular de precesion. Finalmente se ploteara el grafico de la energia en funcion del tiempo y de la trayectoria. ''' vy0 = 0.3 condicion_inicial = sp.array([10, 0, 0, vy0]) p = Planeta(condicion_inicial, 10**(-2.375)) t_final = 180 * 30 #factor 30 por las orbitas pasos = 40000 dt = t_final / (float)(pasos) x = sp.zeros(pasos) y = sp.zeros(pasos) vx = sp.zeros(pasos) vy = sp.zeros(pasos) r = sp.zeros(pasos) energia = sp.zeros(pasos) perihelio = [[], [], []] # se trabajara con dt,dy y dx ''' Condiciones iniciales''' [x[0], y[0], vx[0], vy[0]] = condicion_inicial r[0] = sp.sqrt(x[0]**2 + y[0]**2) energia[0] = p.energia_total()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from planeta import Planeta, G, M, m
from RK4 import paso_rk4
import math
import numpy as np
from matplotlib import pyplot as plt
import pdb
condicion_inicial = [10, 0, 0, 10]
p = Planeta(condicion_inicial)
a = p.energia_total()
print("energia = " + str(a))
def ecuacion_de_movimiento_rk4(t, Y):
"""
Adaptacion de la función ecuacion_de_movimiento
de la clase Planeta para ajustarse al modulo
RK4 existe.
Implementa la ecuación de movimiento, como sistema de ecuaciones de
primer orden.
El planeta se rige por la segunda ley de Newton en donde asumiremos
que la unica fuerza que lo afecta es la atraccion gravitatoria
del sol:
F = ma = GmM/r^2
'''
PARTE2
En este script se realizaran graficos de energia y trayectoria usando verlet velocity
INCREIBLE, NECESITA UN DT MUUUUUUUY CHICO PARA TENER LA TRAYECTORIA DE VERLET2 Y RK4, SIN EMBARGO, EN LA ENERGIA SIGUE OSCILANDO ALREDEDOR DEL -0.05
'''
'''
Caso verlet velocity con alpha=0
Caso interesante voy=0.1, se escapa, graficos de energiat con kine y potencial + trayectoria
Condiciones iniciales, definicion de objeto, paso y arreglos de ceros a llenar
'''
vy0=0.3
condicion_inicial = [10, 0, 0, vy0]
p = Planeta(condicion_inicial)
t_final = 6000
pasos = 50000
dt= t_final / (float)(pasos)
x = sp.zeros(pasos)
y = sp.zeros(pasos)
vx = sp.zeros(pasos)
vy = sp.zeros(pasos)
energia=sp.zeros(pasos)
x[0],y[0],vx[0],vy[0] = condicion_inicial
energia[0]=p.energia_total()
''' Calculo de vectores usando metodo de verlet velocity'''
for i in range (1,pasos):
resultenergy=p.energia_total()
p.avanza_verletvelocity(dt)
#!/usr/bin/env python # -*- coding: utf-8 -*- from planeta import Planeta condicion_inicial = [10, 0, 0, XXX] p = Planeta(condicion_inicial) ''' Complete el código a continuación. '''
import matplotlib.pyplot as plt import scipy as sp from planeta import Planeta ''' PARTE2 En este script se graficara la energia y trayectoria usando verlet version 2. caso verlet avanzado con alpha 0 con dt muy pequeno queda muy preciso y perfecto, energia constante ''' ''' Condiciones iniciales, se define objeto de clase Planeta, el paso de tiempo y los arreglos de ceros de las distintas variables''' vy0=0.3 condicion_inicial = sp.array([10, 0, 0, vy0]) p = Planeta(condicion_inicial) t_final = 6000 pasos = 50000 dt= t_final / (float)(pasos) x = sp.zeros(pasos) y = sp.zeros(pasos) vx = sp.zeros(pasos) vy = sp.zeros(pasos) energia=sp.zeros(pasos) [x[0],y[0],vx[0],vy[0]] = condicion_inicial energia[0]=p.energia_total() ''' Se define el segundo valor del vector yactual mediante rk4 (en este caso) puesto que verlet2 lo necesita para la iteracion''' p.avanza_rk4(dt) resultados = p.y_actual x[1] = resultados[0] y[1] = resultados[1] vx[1] = resultados[2]
En este script se realizara el grafico de energia y trayectoria usando euler. MIENTRAS MAS CHICO EL DT MAS PRECISO ES PARA LA ENERGIA PERO LA TRAYECTORIA NO ''' ''' Condiciones iniciales mas la creacion del objeto de clase Planeta. Paso arbitrario. Arreglos de ceros a los que se les ira anexando valores dado el metodo de euler. ''' vy0=0.3 condicion_inicial = sp.array([10, 0, 0, vy0]) p = Planeta(condicion_inicial) t_final = 6000 pasos = 50000 dt= t_final / (float)(pasos) x = sp.zeros(pasos) y = sp.zeros(pasos) vx = sp.zeros(pasos) vy = sp.zeros(pasos) energia=sp.zeros(pasos) [x[0],y[0],vx[0],vy[0]] = condicion_inicial energia[0]=p.energia_total() '''Caso euler explicito con alpha=0 .Se recorrera con un for para ir obteniendo para cada tiempo un vector de 4 componentes [x,y,vx,vy] '''
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from planeta import Planeta
import matplotlib.pyplot as plt
import numpy as np
alpha = 0
condicion_inicial = [10, 0, 0, 0.2]
p = Planeta(condicion_inicial,alpha)
print "Energia Total", p.energia_total()
contador = 0
x=np.zeros(100001)
y=np.zeros(100001)
t=np.linspace(0,2000,100001)
E_total = np.zeros(100001)
while contador<=100000:
E_total[contador] = p.energia_total()
x[contador] = p.y_actual[0]
y[contador] = p.y_actual[1]
p.avanza_verlet(0.02)
contador +=1
print np.shape(t),np.shape(x)
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Orbitas con Metodo de Verlet")
plt.plot(x,y,'-')
plt.savefig("Orbitas con Metodo de Verlet")
plt.show()
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
#Condiciones iniciales
condicion_inicial=[10, 0, 0, 0.27] #Escogi Vy=0.27
p=Planeta(condicion_inicial)
Pasos=800 #En este metodo necesite una cantidad moderada de pasos
h=800/Pasos #para que los gráficos den cosas razonables. Con tiempo igual a
T=np.linspace(0,800, Pasos) #800 se logran las 5 vueltas
x=[10]
y=[0]
Ene=[p.EneActual]
N=1 #Variable auxiliar para interar
while N<Pasos: #Aplica el metodo de runge-kutta 4 definido en la clase planeta.
p.avanza_rk4(h)
N+=1
x.append(p.y_actual[0])
y.append(p.y_actual[1])
p.energia_total()
Ene.append(p.EneActual)
#Plots
fig=plt.figure()
fig.add_subplot(211)
plt.plot(x,y)
plt.title('$Trayectoria$ $y$ $Energia$ $vs$ $Tiempo$ \n $RK4$ $Con$ $v_{y}(0)=0.27$')
plt.xlabel('$x$')
plt.ylabel('$y$')
fig.add_subplot(212)
plt.plot(T, Ene)
plt.xlabel('$Tiempo$')
def orbitar(CI,solucion, prt=True):
'''
Esta función es cool, porque le entregas las condiciones iniciales (CI)
en forma de x0,y0,vx0,vy0, además de un string con el tipo de solución
que quieres, como 'euler', 'rk4' o 'verlet' y nos devuelve las coordenadas
x,y y la energia total del planeta. Además de un ploteo de la órbita, apropi-
adamente labelado y un ploteo de la energía vs el tiempo.
La ultima parte es para que plotee, el valor default es que
plotee (true or false).
Ejemplo de uso:
orbitar([10,0,0,0.1],'verlet')
x=[0,0.1,...]
y=[0,0.3,...]
energia=[7,8,...]
'''
if solucion=='euler':
n= 2500 #grande y dsps se arregla
if solucion=='rk4':
n= 5000 #grande y dsps se arregla
if solucion=='verlet':
n=800
Aiur= Planeta(CI) #se crea el planeta
if solucion=='verlet_reloaded': #caso especial para la ultima parte
n=6000
Aiur= Planeta(CI,alpha=alpha2) #si es el verlet bkn se parcha
dt= 1 #error si es muy chico
tmax=n*dt
x=[] #listas vacias a llenar
y=[]
pylon=[] #energia
x= np.append(x,CI[0]) #llenamos con el primer termino
y= np.append(y,CI[1])
pylon= np.append(pylon,Aiur.energia_total())
for i in range(tmax): #aca se hace la iteracion del paso
if solucion=='euler':
Aiur.avanza_euler(dt)
if solucion=='rk4':
Aiur.avanza_rk4(dt)
if solucion=='verlet' or solucion=='verlet_reloaded':
Aiur.avanza_verlet(dt)
xn,yn,vxn,vyn=Aiur.y_now
x= np.append(x,xn)
y= np.append(y,yn)
pylon= np.append(pylon,Aiur.energia_total())
times=np.linspace(0,tmax,tmax+1)
if prt==True:
fig1=plt.figure(1) #aca se plotea, muy standar
fig1.clf()
if solucion=='euler':
plt.plot(x,y,'r',label= 'Trayectoria metodo Euler')
plt.title('Trayectoria metodo Euler')
if solucion=='rk4':
plt.plot(x,y,'r',label= 'Trayectoria metodo RK4')
plt.title('Trayectoria metodo RK4')
if solucion=='verlet' or solucion=='verlet_reloaded':
plt.plot(x,y,'r',label= 'Trayectoria metodo Verlet')
plt.title('Trayectoria metodo Verlet')
plt.xlabel('X')
plt.ylabel('Y')
plt.savefig('verlet_rld.png')
plt.draw()
plt.show()
fig2=plt.figure(2)
fig2.clf()
plt.plot(times, pylon,'g')
plt.xlabel('Tiempo')
plt.ylabel('Energia')
plt.title('Tiempo vs Energia')
plt.savefig('verlet_rld_energia.png')
plt.draw()
plt.show()
return x,y,pylon
def test_mover_planeta_sentido_antihorario_angulo_ok(self):
planeta1 = Planeta(nombre="Tierra", angulo=0, distancia=100,
velocidad=1, sentido=1)
planeta1.step()
self.assertEqual(planeta1.pos.phi, 1)
planeta1.step()
self.assertEqual(planeta1.pos.phi, 2)
planeta2 = Planeta(nombre="Tierra", angulo=0, distancia=100,
velocidad=3, sentido=1)
planeta2.step()
self.assertEqual(planeta2.pos.phi, 3)
planeta2.step()
self.assertEqual(planeta2.pos.phi, 6)
planeta3 = Planeta(nombre="Tierra", angulo=360, distancia=100,
velocidad=5, sentido=1)
planeta3.step()
self.assertEqual(planeta3.pos.phi, 5)
planeta3.step()
self.assertEqual(planeta3.pos.phi, 10)
planeta4 = Planeta(nombre="Tierra", angulo=90, distancia=100,
velocidad=5, sentido=1)
planeta4.step()
self.assertEqual(planeta4.pos.phi, 95)
planeta4.step()
self.assertEqual(planeta4.pos.phi, 100)
# -*- coding: utf-8 -*-
'''
Script que utiliza Verlet para calcular y graficar aproximadamente
5 orbitas. Además grafica energia vs tiempo.
'''
import numpy as np
import matplotlib.pyplot as plt
from planeta import Planeta
condicion_inicial = [10, 0, 0, 0.3] #x, y, vx, vy
p = Planeta(condicion_inicial) #se establece condicio inicial como actuales
dt=1
t_total=900 #aproximadamente 5 orbitas
# se crean listas vacias de x, y, Energia
x=[]
y=[]
Energia=[]
#Se agregan condiciones iniciales
x.append(condicion_inicial[0])
y.append(condicion_inicial[1])
Energia.append(p.energia_total())
t=1 #ya se realizo el primer calculo
while t<=t_total:
p.avanza_verlet(dt)
x_siguiente, y_siguiente, vx_siguiente, vy_siguiente = p.y_actual
x.append(x_siguiente)
y.append(y_siguiente)
import matplotlib.pyplot as plt import scipy as sp from planeta import Planeta ''' PARTE2 En este script se realizara el grafico de energia y trayectoria para rk4 ''' ''' Caso rk4 con alpha=0.Se crea al objeto de la clase Planeta. Se define paso y arreglos de cero listos para llenar ''' vy0=0.3 condicion_inicial = sp.array([10, 0, 0, vy0]) p = Planeta(condicion_inicial) t_final = 6000 pasos = 50000 dt= t_final / (float)(pasos) x = sp.zeros(pasos) y = sp.zeros(pasos) vx = sp.zeros(pasos) vy = sp.zeros(pasos) energia=sp.zeros(pasos) ''' Condiciones iniciales''' [x[0],y[0],vx[0],vy[0]] = condicion_inicial energia[0]=p.energia_total() ''' Recorre con el metodo de rk4 el objeto p de la clase Planeta para ir obteniendo el vector [x,y,vx,vy] para cada tiempo dado por el paso '''
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
condicion_inicial = [10, 0, 0, 2]
p = Planeta(condicion_inicial)
dt=np.linspace(0,10000,10001)
Energias=[]
X=[]
Y=[]
for i in (dt):
p.avanza_rk4(dt[i])
Energias.append(p.energia_actual)
X.append(p.y_actual[0])
Y.append(p.y_actual[1])
plt.figure(1)
plt.plot(Energias, dt)
plt.xlabel('energia',fontsize=18)
plt.ylabel('tiempo', fontsize=18)
plt.figure(2)
plt.plot(X, Y)
plt.xlabel('x', fontsize=18)
plt.ylabel('y', fontsize=18)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
condicion_inicial = [10, 0, 0, 0.4]
p = Planeta(condicion_inicial)
dt = 0.1
iteraciones = 50000
x = np.zeros(iteraciones)
y = np.zeros(iteraciones)
energia = np.zeros(iteraciones)
tiempo = np.zeros(iteraciones)
for i in range(iteraciones):
p.avanza_euler(dt)
x[i] = p.y_actual[0]
y[i] = p.y_actual[1]
energia[i] =p.energia_total()
tiempo [i] = p.t_actual
plt.figure(1)
plt.clf()
plt.plot(x,y,color='red')
plt.xlabel('x[m]')
plt.ylabel('y[m]')
#!/usr/bin/env python # -*- coding: utf-8 -*- from planeta import Planeta import numpy as np import matplotlib.pyplot as plt condicion_inicial = [10., 0., 0., 0.3] p = Planeta(condicion_inicial) n_pasos=4000 dt=0.1 X=np.zeros(n_pasos) Y=np.zeros(n_pasos) VX=np.zeros(n_pasos) VY=np.zeros(n_pasos) ET=np.zeros(n_pasos) t_values=np.zeros(n_pasos) X[0]=condicion_inicial[0] Y[0]=condicion_inicial[1] VX[0]=condicion_inicial[2] VY[0]=condicion_inicial[3] ET[0]=p.energia_total() p.avanza_rk4(dt) X[1]=p.y_actual[0] Y[1]=p.y_actual[1]
'''
Este script utiliza la clase Planeta para resolver la órbita de un planeta de
masa 1 kg, orbitando un cuerpo central de masa M = 1.498 x 10^10 kg. El
movimiento es determinado usando un método Runge-Kutta orden 4. Al final se
presentan los resultados en forma de gráficos de la órbita y de la energía en
el tiempo.
'''
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
#Solucion a trayectoria
condicion_inicial = [10.0, 0.0, 0.0, 0.3]
Mars = Planeta(condicion_inicial)
x_pos = []
y_pos = []
energia = []
dt=0.1
for i in range(10000):
x_pos.append(Mars.y_actual[0])
y_pos.append(Mars.y_actual[1])
energia.append(Mars.energia_total())
Mars.avanza_rk4(dt)
x_pos = np.array(x_pos)
y_pos = np.array(y_pos)
energia = np.array(energia)
#Resultados
from planeta import Planeta import scipy.stats import numpy as np ''' PARTE3 Ahora considero el caso alfa no cero, mi rut es 189563752 y se usara verletvelocity para integrar la ecuacion de movimiento. Luego se determinara la posicion del perihelio y la velocidad angular de precesion. Finalmente se ploteara el grafico de la energia en funcion del tiempo y de la trayectoria. ''' vy0=0.3 condicion_inicial = sp.array([10, 0, 0, vy0]) p = Planeta(condicion_inicial, 10**(-2.375)) t_final = 180*30 #factor 30 por las orbitas pasos = 40000 dt= t_final / (float)(pasos) x = sp.zeros(pasos) y = sp.zeros(pasos) vx = sp.zeros(pasos) vy = sp.zeros(pasos) r = sp.zeros(pasos) energia = sp.zeros(pasos) perihelio = [[], [],[] ] # se trabajara con dt,dy y dx ''' Condiciones iniciales''' [x[0],y[0],vx[0],vy[0]] = condicion_inicial r[0] = sp.sqrt(x[0]**2+y[0]**2)
'''
Created on Oct 9, 2019
@author: romina
'''
"""
Programa para probar el pronostico
"""
from planeta import Planeta
from sistema_solar import SistemaSolar
phiv = 0
phif = 0
phib = 0
vulcanos = Planeta("Vulcanos", phiv, 500, 1, -1)
ferengis = Planeta("Ferengis", phif, 2000, 3, -1)
betasoides = Planeta("Betasoides", phib, 1000, 5, 1)
sistema = SistemaSolar(planetas=(vulcanos, ferengis, betasoides), dia=0)
for _ in range(0, 360*10): # 360 es la cantidad de dias del planeta que mas tarda en dar una vuelta
sistema.do_step()
print(sistema.pronostico_clima())
#!/usr/bin/env python # -*- coding: utf-8 -*- from planeta import Planeta import numpy as np import matplotlib.pyplot as plt condicion_inicial = [10., 0., 0., 0.3] p = Planeta(condicion_inicial) n_pasos = 4000 dt = 0.1 X = np.zeros(n_pasos) Y = np.zeros(n_pasos) VX = np.zeros(n_pasos) VY = np.zeros(n_pasos) ET = np.zeros(n_pasos) t_values = np.zeros(n_pasos) X[0] = condicion_inicial[0] Y[0] = condicion_inicial[1] VX[0] = condicion_inicial[2] VY[0] = condicion_inicial[3] ET[0] = p.energia_total() p.avanza_rk4(dt) X[1] = p.y_actual[0] Y[1] = p.y_actual[1] VX[1] = p.y_actual[2]
from planeta import Planeta import numpy as np import matplotlib.pyplot as plt dty0=0.3#condicion inicial de velocidad en y condicion_inicial = np.array([10., 0, 0, dty0]) p = Planeta(condicion_inicial) t_fin = 3000.#tiempo maximo num_pasos = 2000+1#intervalos dt= t_fin / (float)(num_pasos)#discretisacion #crear los arreglos a usar mas adelante x = np.zeros(num_pasos) y = np.zeros(num_pasos) dtx = np.zeros(num_pasos) dty = np.zeros(num_pasos) energia = np.zeros(num_pasos) #se inician los valores para las variables [x[0],y[0],dtx[0],dty[0]] = condicion_inicial energia[0] = p.energia_total() """implementacion de verlet con alfa distinto de cero""" """ #da el primer paso usando RK 4, para continuar con el metodo de verlet p.avanza_rk4(dt) aux = p.y_actual x[1] = aux[0] y[1] = aux[1] dtx[1] = aux[2]
# -*- coding: utf-8 -*-
'''
Programa que plotea las orbitas de un planeta. El metodo usado es verlet
'''
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
fig=plt.figure()
fig.clf()
condicion_inicial = [10, 0, 0, 0.25]
Shakuras = Planeta(condicion_inicial)
N=3*np.int(1e4)
dt=1000./N
t=np.linspace(0,1000,N)
x=np.zeros(N)
y=np.zeros(N)
E=np.zeros(N)
x[0]=condicion_inicial[0]
y[0]=condicion_inicial[1]
E[0]=Shakuras.energia_total()
for n in range(1,N):
Shakuras.avanza_verlet(dt)
x[n]=Shakuras.y_actual[0]
y[n]=Shakuras.y_actual[1]
# -*- coding: utf-8 -*-
from planeta import Planeta
import matplotlib.pyplot as plt
import numpy as np
#Main
condicion_inicial = np.array([10.0, 0.0, 0.0, 0.25]) #Vy inicial = 0.25
p = Planeta(condicion_inicial)
#Inicalización
t_final = 900.0
dt = 0.1
N_pasos= int(t_final/dt)
x = np.zeros(N_pasos)
y = np.zeros(N_pasos)
vx = np.zeros(N_pasos)
vy = np.zeros(N_pasos)
E = np.zeros(N_pasos)
#Integración
[x[0],y[0],vx[0],vy[0]] = condicion_inicial
E[0] = p.energia_total()
for i in range(1,N_pasos):
p.avanza_rk4(dt)
xi, yi, vxi, vyi = p.y_actual
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Script que utiliza Verlet para calcular y graficar aproximadamente
30 orbitas considerando alpha distinto de 0. Además grafica energia vs tiempo.
'''
import numpy as np
import matplotlib.pyplot as plt
from planeta import Planeta
condicion_inicial = [10, 0, 0, 0.3]
p = Planeta(condicion_inicial, alpha = 10**(-2.257))
# periodo aproximado por tercera ley de kepler
T = np.sqrt(4*np.pi**2*8**3) # = 142 aproximadamente
t_total = 30*T
# se crean arreglos vacios de x, y, Energia
x = np.array([])
y = np.array([])
Energia = np.array([])
#Se agregan condiciones iniciales
x = np.append(x,10)
y = np.append(y,0)
Energia = np.append(Energia,p.energia_total())
dt = 1
t = 1
while t<= t_total:
p.avanza_verlet(dt)
''' Este script utiliza la clase planeta para integrar la trayectoria de aproximadamente 5 orbitas con el metodo de verlet, graficando la trayectoria y la energia vs tiempo en cada momento. Grafica dos veces energia vs tiempo con el fin de dejarlo en dos escalas: una de cerca para ver a forma de la funcion y otra mas de lejos para poder comparar con otros metodos menos eficientes. Utiliza alpha=0 en el potencial. ''' from planeta import Planeta import numpy as np import matplotlib.pyplot as plt condicion_inicial = [10, 0, 0, 0.4] p = Planeta(condicion_inicial) N_steps = 8000 dt=4000./N_steps t=np.linspace(0,4000,N_steps) #creamos los arrays en que se guardara la informacion x= np.zeros(N_steps) y= np.zeros(N_steps) vx= np.zeros(N_steps) vy= np.zeros(N_steps) energia = np.zeros(N_steps) x[0]= 10 y[0]= 0 energia[0]=p.energia_actual
'''
Este script utiliza la clase Planeta para resolver la órbita de un planeta de
masa 1 kg, orbitando un cuerpo central de masa M = 1.498 x 10^10 kg. El
movimiento es determinado usando el método de Verlet. Al final se
presentan los resultados en forma de gráficos de la órbita y de la energía en
el tiempo.
'''
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
#Solucion a trayectoria
condicion_inicial = [10.0, 0.0, 0.0, 0.3]
Mars = Planeta(condicion_inicial)
x_pos = []
y_pos = []
energia = []
dt = 0.1
x_pos.append(Mars.y_actual[0])
y_pos.append(Mars.y_actual[1])
energia.append(Mars.energia_total())
Mars.avanza_rk4(dt)
for i in range(10000):
x_pos.append(Mars.y_actual[0])
y_pos.append(Mars.y_actual[1])
energia.append(Mars.energia_total())
Mars.avanza_verlet(dt)
x_pos = np.array(x_pos)
import numpy as np
import matplotlib.pyplot as plt
from planeta import Planeta
"""Solucion con verlet"""
condicion_inicial = [10, 0, 0, 0.3] # x, y, vx, vy
p = Planeta(condicion_inicial) # se establece condicio inicial como actuales
pasos = 16500
dt = 8000.0 / pasos
t = np.linspace(0, 8000, pasos) # aproximadamente 5 orbitas
# se crean listas vacias de x, y, Energia
x = np.zeros(pasos)
y = np.zeros(pasos)
e = np.zeros(pasos)
# Se agregan condiciones iniciales
x[0] = 0
y[0] = 0
e[0] = p.energia_total()
for i in range(1, pasos):
p.avanza_verlet(dt)
x[i] = p.y_actual[0]
y[i] = p.y_actual[1]
e[i] = p.energia_total()
p.energia_total()
# Energia.append(p.energia_total())
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from planeta import Planeta
import matplotlib.pyplot as plt
import numpy as np
alpha = 0
condicion_inicial = [10, 0, 0, 0.2]
p = Planeta(condicion_inicial,alpha)
print "Energia Total", p.energia_total()
contador = 0
x=np.zeros(100001)
y=np.zeros(100001)
t=np.linspace(0,2000,100001)
E_total = np.zeros(100001)
while contador<=100000:
E_total[contador] = p.energia_total()
x[contador] = p.y_actual[0]
y[contador] = p.y_actual[1]
p.avanza_euler(0.02)
contador +=1
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Orbitas con Metodo de Euler")
plt.plot(x,y,'-')
# -*- coding: utf-8 -*-
from planeta import Planeta
import matplotlib.pyplot as plt
import numpy as np
#Main
condicion_inicial = np.array([10.0, 0.0, 0.0, 0.25]) #Vy inicial = 0.25
p = Planeta(condicion_inicial)
#Inicalización
t_final = 900.0 #5 vueltas con euler
dt = 0.1
N_pasos= int(t_final/dt)
x = np.zeros(N_pasos)
y = np.zeros(N_pasos)
vx = np.zeros(N_pasos)
vy = np.zeros(N_pasos)
E = np.zeros(N_pasos)
[x[0],y[0],vx[0],vy[0]] = condicion_inicial
E[0] = p.energia_total()
#Integración
for i in range(1,N_pasos):
p.avanza_euler(dt)
xi, yi, vxi, vyi = p.y_actual
# -*- coding: utf-8 -*-
"""
Script que utiliza Euler explicito para calcular y graficar aproximadamente
5 orbitas. Además grafica energia vs tiempo.
"""
import numpy as np
import matplotlib.pyplot as plt
from planeta import Planeta
condicion_inicial = [10, 0, 0, 0.3] # x, y, vx, vy
p = Planeta(condicion_inicial) # se establece condicio inicial como actuales
t_total = 900 # aproximadamente 5 orbitas
# se crean listas vacias de x, y, Energia
x = []
y = []
Energia = []
# Se agregan condiciones iniciales
x.append(condicion_inicial[0])
y.append(condicion_inicial[1])
Energia.append(p.energia_total())
dt = 1
t = 1 # ya se realizo el primer calculo
while t <= t_total:
p.avanza_euler(dt)
x_siguiente, y_siguiente, vx_siguiente, vy_siguiente = p.y_actual
x.append(x_siguiente)
y.append(y_siguiente)
dphi = phi - phi_anterior
dt = t - t_anterior
vel_angular[i - 1] = dphi / dt
t_anterior = t
phi_anterior = phi
vel_angular = np.round(vel_angular, 7)
return vel_angular
'''--------------------------------------------------------------------------'''
condicion_inicial = np.array([10., 0, 0, VY0])
p = Planeta(condicion_inicial, 10**(-2.844))
t_final = 180. * 30
numero_pasos = 30000 + 1
dt = t_final / (float)(numero_pasos)
x = np.zeros(numero_pasos)
y = np.zeros(numero_pasos)
vx = np.zeros(numero_pasos)
vy = np.zeros(numero_pasos)
r = np.zeros(numero_pasos)
energia = np.zeros(numero_pasos)
perihelio = [[], [], []]
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
condicion_inicial = [10., 0., 0., 0.3]
p = Planeta(condicion_inicial)
n_pasos = 4000
dt = 0.1
X = np.zeros(n_pasos)
Y = np.zeros(n_pasos)
VX = np.zeros(n_pasos)
VY = np.zeros(n_pasos)
ET = np.zeros(n_pasos)
t_values = np.zeros(n_pasos)
X[0] = condicion_inicial[0]
Y[0] = condicion_inicial[1]
VX[0] = condicion_inicial[2]
VY[0] = condicion_inicial[3]
ET[0] = p.energia_total()
for i in range(1, n_pasos):
p.avanza_euler(dt)
X[i] = p.y_actual[0]
Y[i] = p.y_actual[1]
#!/usr/bin/env python # -*- coding: utf-8 -*- ''' Este script utiliza la clase planeta para integrar la trayectoria de aproximadamente 5 orbitas con el metodo de euler explicito, graficando la trayectoria y la energia vs tiempo en cada momento. Utiliza alpha=0 en el potencial. ''' from planeta import Planeta import numpy as np import matplotlib.pyplot as plt condicion_inicial = [10, 0, 0, 0.4] p = Planeta(condicion_inicial) N_steps = 100000 dt=4000./N_steps t=np.linspace(0,4000,N_steps) #creamos los arrays en que se guardara la informacion x= np.zeros(N_steps) y= np.zeros(N_steps) energia = np.zeros(N_steps) x[0]= 10 y[0]= 0 energia[0]=p.energia_actual for i in range(1, N_steps):
Este script utiliza la clase Planeta para resolver la órbita de un planeta de
masa 1 kg, orbitando un cuerpo central de masa M = 1.498 x 10^10 kg. El
movimiento es determinado usando el método de Verlet. En este script se añade
el parámetro correspondiente a la corrección relativista para órbitas cercanas
al cuerpo central. Al final se presentan los resultados en forma de gráficos de
la órbita y de la energía en el tiempo.
'''
from planeta import Planeta
import numpy as np
import matplotlib.pyplot as plt
#Solucion a trayectoria
condicion_inicial = [10.0, 0.0, 0.0, 0.3]
Mercury = Planeta(condicion_inicial, 10**(-2.350))
x_pos = [Mercury.y_actual[0]]
y_pos = [Mercury.y_actual[1]]
energia = [Mercury.energia_total()]
dt = 0.01
Mercury.avanza_rk4(dt)
for i in range(600000):
x_pos.append(Mercury.y_actual[0])
y_pos.append(Mercury.y_actual[1])
energia.append(Mercury.energia_total())
Mercury.avanza_verlet(dt)
x_pos = np.array(x_pos)
y_pos = np.array(y_pos)
energia = np.array(energia)