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)