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)
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(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 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 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)
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 condicion_inicial = [10, 0, 0, XXX] p = Planeta(condicion_inicial) ''' Complete el código a continuación. '''
'''
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())
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
'''=========================================================
@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("")
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()
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"]
def test_crear_planeta_distancia_negativa_ok(self):
Planeta(nombre="Tierra", angulo=0, distancia=-100,
velocidad=1, sentido=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 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)
