return xpos, ypos, tpos v0, vy = init_c(1, 0, 0) sim_params = pt.grav_ m, x0, y0, v0, a0 = 1., 1., 0., 5., 70 deltat = .0001 m1 = "Euler" m2 = "Euler-Cromer" m3 = "Midpoint" num_method = m2 earth = pt.Particle(x0, y0, v0, a0) earth_force = fr.Forces(Newton_again, sim_params) earth.set_force(earth_force) euler = sol.Solver(earth, num_method, deltat) xvac, yvac, tvac = integrate(euler) m2, x02, y02, v02, a02 = 1., 1.5, 0., 5., 70 mars = pt.Particle(x02, y02, v02, a02) f2 = fr.Forces(Newton_again, sim_params) mars.set_force(f2) i2 = sol.Solver(mars, num_method, deltat) xvac2, yvac2, tvac2 = integrate(i2) sx, sy = 0, 0 ex, ey = 1, 0.
"""This expression assumes x0 = 0 and y0 = 0 and m = 1"""
v0x = v0 * np.cos(np.radians(a0))
v0y = v0 * np.sin(np.radians(a0))
xa = v0x * (1. - np.exp(-pt.DRAG * tf)) / pt.DRAG
ya = (v0y + pt.GRAV / pt.DRAG) * (1. - np.exp(-pt.DRAG * tf)) \
- pt.GRAV * tf
return xa, ya / pt.DRAG
################################################################################
# BLOQUE PRINCIPAL DE INSTRUCCIONES
deltat = 0.005
x0, y0, v0, a0 = 0., 0., 1., 75.
ball = pt.Particle("Ball", x0, y0, v0, a0)
ball1 = pt.Particle("Ball1", x0, y0, v0, a0)
ball2 = pt.Particle("Ball2", x0, y0, v0, a0)
print(ball)
print(ball1)
print(ball2)
xpos = []
ypos = []
tpos = []
while True:
x, y, _, _, t = ball.get_state()
if y < 0: break
xpos.append(x)
ypos.append(y)
################################################################################
# BLOQUE PRINCIPAL DE INSTRUCCIONES
# v0, vy = cond_init(1, 0, 0) #orbita circular
k = 1.5 # orbita eliptica
# print(v0)
x0, y0, v0, a0, m = k, .0, k, 90., 1.
sim_params = m, GMe, W
deltat = 0.01 / 128
m1 = "Euler"
m2 = "Euler-Cromer"
m3 = "Midpoint"
satellite = pt.Particle("Satellite", x0, y0, v0, a0,
m) # Revisar por que a0 es 90?
satellite_force = fr.Forces(universal_gravity, sim_params)
satellite.set_force(satellite_force)
euler = sl.Solver(satellite, m2,
deltat) # El metodo mas estable es Euler Cromer
xpos, ypos, tpos = [], [], []
cont = 0
em = []
vel = []
for i in range(200000):
xc, yc, vxc, vyc, tc = satellite.get_state()
v = np.sqrt(vxc**2 + vyc**2)
vel.append(v)
emt = total_mechanic_energy(v, m, xc, yc)
em.append(round(emt, 2))
return xpos, ypos, tpos, areas
sim_params = pt.grav_
deltat = 0.01 / 256
m1 = "Euler"
m2 = "Euler-Cromer"
m3 = "Midpoint"
num_method = m2 # m1 # m3
# k = 2 * np.pi
m, x0, y0, v0, a0 = 1., 1.5, .0, 1.5, 90. # v0 = k
earth = pt.Particle(x0, y0, v0, a0)
earth_force = fr.Forces(Newton_again, sim_params)
earth.set_force(earth_force)
euler = sl.Solver(earth, num_method, deltat)
xvac, yvac, tvac, area = integrate(euler)
print("Area Ini:", area[0], ", Area Fin:", area[-1])
# Muestra la orbita circular o eliptica
# fig, ax = plt.subplots()
# ax.plot(xvac, yvac, '--', c = 'purple', label=num_method)
#
# ax.set(xlabel='x (a.u.)', ylabel='y (a.u.)')
# Muestra grafica area vs tiempo
fig, ax = plt.subplots()
return emt
# v0, vy = init_c(1, 0, 0) #orbita circular
k = 1.5 # orbita eliptica
m, x0, y0, v0, a0 = 1., k, .0, k, 90.
sim_params = m, GMe, W
deltat = 0.01 / 128
m1 = "Euler"
m2 = "Euler-Cromer"
m3 = "Midpoint"
num_method = m2 # m1 # m3
satellite = pt.Particle(x0, y0, v0, a0)
satellite_force = fr.Forces(Newton_again, sim_params)
satellite.set_force(satellite_force)
euler = sl.Solver(satellite, num_method,
deltat) # El metodo mas estable es Euler Cromer
xpos, ypos, tpos, em = [], [], [], []
cont = 0
for i in range(200000):
xc, yc, vxc, vyc, tc = satellite.get_state()
v = np.sqrt(vxc**2 + vyc**2)
emt = mechanic_energy(v, m, xc, yc)
em.append(round(emt, 2))
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
return emt
################################################################################
# BLOQUE PRINCIPAL DE INSTRUCCIONES
v0, vy = cond_init(1, 0, 0)
x0, y0, v0, a0, m = 1., .0, v0, 90., 1.
sim_params = m, GM
deltat = 0.01 / 499.998 # para euler cromer deltat = 0.01/499.998
m1 = "Euler"
m2 = "Euler-Cromer"
m3 = "Midpoint"
earth = pt.Particle("Earth", x0, y0, v0, a0, m) # Revisar por que a0 es 90?
earth_force = fr.Forces(universal_gravity, sim_params)
earth.set_force(earth_force)
euler = sl.Solver(earth, m2, deltat) # El metodo mas estable es Euler Cromer
xpos, ypos, tpos = [], [], []
cont = 0
em = []
for i in range(200000):
xc, yc, vxc, vyc, tc = earth.get_state()
v = np.sqrt(vxc**2 + vyc**2)
emt = total_mechanic_energy(v, m)
em.append(round(emt, 2))
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
self.objs.set_state(x, y, vx, vy, t)
methods = {
"Euler": euler_step,
"Euler-Cromer": euler_cromer_step,
"Midpoint": midpoint_step
}
if __name__ == "__main__":
import sys
sys.path.insert(0, '../')
import particle.particle as pt
ball = pt.Particle("aa", 3., 2., 1., 45.)
euler = Solver(ball, "Midpoint", 0.25)
print("Integrator", euler)
euler.set_step(0.01)
euler.set_method("Euler-Cromer")
print("Method:", euler.get_method() + "; Step:", euler.get_step())
"""
ball2 = pt.Particle("aa2", 3., 2., 1., 45.)
euler2 = Solver(ball2, "Euler-Cromer", 0.25)
print("Integrator", euler2)
euler2.set_step(0.01)
euler2.set_method("Euler")
print("Method:", euler2.get_method() + "; Step:", euler2.get_step())
for i in range(500001):
xc, yc, _, _, tc = planet.get_state()
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
energy.append(planet.get_energy())
numeric.midpoint_step(deltat)
m1, x01, y01, v01, a01 = 1., 3., 0., 2., 90
m2, x02, y02, v02, a02 = 1., 1., 0., 8., 90
deltat = 0.00001
########################################################
planet1 = pt.Particle("Planet 1", x02, y02, v02, a02, m2)
planet1.set_force(fr.Forces(grav_force, pt.GM))
planet2 = pt.Particle("Planet 2", x02, y02, v02, a02, m2)
planet2.set_force(fr.Forces(grav_force, pt.GM))
planet3 = pt.Particle("Planet 3", x02, y02, v02, a02, m2)
planet3.set_force(fr.Forces(grav_force, pt.GM))
xpos1, ypos1, tpos1, energy1 = [], [], [], []
xpos2, ypos2, tpos2, energy2 = [], [], [], []
xpos3, ypos3, tpos3, energy3 = [], [], [], []
numeric1 = sv.Solver(planet1, "Euler", deltat)
numeric2 = sv.Solver(planet2, "Euler-Cromer", deltat)
numeric3 = sv.Solver(planet3, "Midpoint", deltat)
def midpoint(planet, numeric, xpos, ypos, tpos):
for i in range(5002):
xc, yc, _, _, tc = planet.get_state()
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
numeric.midpoint_step(deltat)
#Initial Variables and lists
m, x0, y0, v0, a0 = 1., 3., 0., 2., 90
deltat = 0.001
sim_params = pt.GM
planet = pt.Particle("Planet X", x0, y0, v0, a0, m)
planet_force = fr.Forces(grav_force, sim_params)
planet.set_force(planet_force)
planet2 = pt.Particle("Planet Y", x0, y0, v0, a0, m)
planet2.set_force(planet_force)
planet3 = pt.Particle("Planet Z", x0, y0, v0, a0, m)
planet3.set_force(planet_force)
xposEuler = []
yposEuler = []
tposEuler = []
xposEulerCromer = []
yposEulerCromer = []
obj.do_step()
senel += 1
return xpos, ypos, tpos
# BEGINNING-OF-EXECUTION
deltat, num_method = .001, "Euler-Cromer"
x0, y0, v0, a0 = 1., .0, .9, 90
r0 = np.sqrt(x0**2 + y0**2)
v0 = 1.3 * np.sqrt(GM / r0)
# create free-falling Particle
sim_params = GM
planet = pt.Particle("Earth", x0, y0, v0, a0)
the_force = fr.Forces(newton_again, sim_params)
planet.set_force(the_force)
intor = sol.Solver(planet, num_method, deltat)
xvac, yvac, tvac = integrate(intor)
print("x", len(xvac), "y", len(xvac))
# generate plots
fig, ax = plt.subplots()
label = 'x0 = %.2f, y0 = %.2f, v0 = %.2f, a0 = %.2f' % (x0, y0, v0, a0)
ax.plot(xvac, yvac, '-', label=label)
ax.set_aspect('equal')
def midpoint(planet, numeric, xpos, ypos, tpos):
for i in range(101):
xc, yc, _, _, tc = planet.get_state()
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
energy.append(planet.get_energy())
numeric.midpoint_step(deltat)
m1, x01, y01, v01, a01 = 1., 2., 0., 4.442882938, 90
m2, x02, y02, v02, a02 = 1., 1., 0., 8., 90
deltat = 0.001
planet1 = pt.Particle("Planet X", x01, y01, v01, a01, m1)
planet1.set_force(fr.Forces(grav_force, pt.GM))
planet2 = pt.Particle("Planet Y", x02, y02, v02, a02, m2)
planet2.set_force(fr.Forces(grav_force, pt.GM))
xpos1, ypos1, tpos1, energy1 = [], [], [], []
xpos2, ypos2, tpos2, energy2 = [], [], [], []
numeric1 = sv.Solver(planet1, "Euler-Cromer", deltat)
numeric2 = sv.Solver(planet2, "Euler-Cromer", deltat)
euler_cromer(planet1, numeric1, xpos1, ypos1, tpos1, energy1)
euler_cromer(planet2, numeric2, xpos2, ypos2, tpos2, energy2)
#Generate Plots -------------------------------------------------
final_state.append((x, y, vx, vy, t))
for idx in range(len(self.objs)):
self.objs[idx].set_state(*final_state[idx])
methods = {
"Euler": euler_step,
"Euler-Cromer": euler_cromer_step,
"Midpoint": midpoint_step
}
################################################################################
# BLOQUE PRINCIPAL DE INSTRUCCIONES
if __name__ == "__main__":
import sys
sys.path.insert(0, '../')
import particle.particle as pt
ball = pt.Particle("ball", 3., 2., 1., 45.)
euler = Solver(ball, "Midpoint", 0.25)
print("Integrator", euler)
euler.set_step(0.01)
euler.set_method("Euler-Cromer")
euler.do_step()
print("Method:", euler.get_method() + "; Step:", euler.get_step())
if yc < 0: break
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
obj.do_step()
return xpos, ypos, tpos
# BEGINNING-OF-EXECUTION
deltat, num_method = .005, "Midpoint"
m, x0, y0, v0, a0 = 1., 0., .0, 1., 75
# create free-falling Particle
sim_params = pt.grav_ # gravity
vacuum = pt.Particle(x0, y0, v0, a0)
the_force = fr.Forces(free_falling, sim_params)
vacuum.set_force(the_force)
intgr = sol.Solver(vacuum, num_method, deltat)
xvac, yvac, tvac = integrate(intgr)
# create falling Particle with linear drag
sim_params = m, pt.grav_, C_DRAG # mass, gravity, drag
linear = pt.Particle(x0, y0, v0, a0)
the_force = fr.Forces(linear_drag, sim_params)
linear.set_force(the_force)
intgr = sol.Solver(linear, num_method, deltat)
xlin, ylin, tlin = integrate(intgr)
# create falling Particle with quadratic drag
sim_params = m, pt.grav_, C_DRAG # mass, gravity, drag
for i in range(13700):
xc, yc, vxc, vyc, tc = planet.get_state()
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
numeric.euler_cromer_step(deltat)
area.append(.5 * deltat * (xc * vyc - yc * vxc))
#Initial Variables and lists
m, x0, y0, v0, a0 = 1., 10., 0., 1, 90
deltat = 0.001
sim_params = pt.GM
planet2 = pt.Particle("Planet X", x0, y0, v0, a0, m)
planet_force = fr.Forces(grav_force, sim_params)
planet2.set_force(planet_force)
xposEulerCromer = []
yposEulerCromer = []
tposEulerCromer = []
areas = []
numeric2 = sv.Solver(planet2, "Euler-Cromer", deltat)
euler_cromer(planet2, numeric2, xposEulerCromer, yposEulerCromer,
tposEulerCromer, areas)
#Generate Plots
#print(xposEulerCromer)
def resistive_falling(state, params):
xp, yp, vxp, vyp, _ = state
mass, grav, drag = params
axp = -drag * vxp / mass
ayp = -grav - drag * vyp / mass
return vxp, vyp, axp, ayp, 1.
################################################################################
# BLOQUE PRINCIPAL DE INSTRUCCIONES
deltat = .01
m, x0, y0, v0, a0 = 1., 0., .0, 1., 45
sim_params = m, pt.GRAV, pt.DRAG # mass, gravity, drag
ball = pt.Particle(x0, y0, v0, a0, m)
ball_force = fr.Forces(resistive_falling, sim_params)
ball.set_force(ball_force)
print("Projectile:", ball)
xpos, ypos, tpos = [], [], []
while True:
xc, yc, _, _, tc = ball.get_state()
if yc < 0: break
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
ball.euler_step(deltat)
fig, ax = plt.subplots()
ax.plot(xpos, ypos, '--', label='numerical')
x, y, vx, vy, t = state
dxdt, dydt, dvxdt, dvydt, dtdt = self.objs.force.get_force(state)
vx = vx + dvxdt * dt
vy = vy + dvydt * dt
x = x + .5 * (vx + dxdt) * dt
y = y + .5 * (vy + dydt) * dt
t = t + dtdt * dt
self.objs.set_state(x, y, vx, vy, t)
methods = {"Euler": euler_step,
"Euler-Cromer": euler_cromer_step,
"Midpoint": midpoint_step}
if __name__ == "__main__":
import sys
sys.path.insert(0, '../')
import particle.particle as pt
ball = pt.Particle(3., 2., 1., 45.)
euler = Solver(ball, "Midpoint", 0.25)
print("Integrator", euler)
euler.set_step(0.01)
euler.set_method("Euler-Cromer")
print("Method:", euler.get_method() + "; Step:", euler.get_step())
def exact_sol(tf, x0, y0, v0, a0):
v0x = v0 * np.cos(np.radians(a0))
v0y = v0 * np.sin(np.radians(a0))
xa = x0 + v0x * tf
ya = y0 + v0y * tf - .5 * pt.GRAV * tf ** 2
return xa, ya
###############################################
deltat = 0.01
x0, y0, v0, a0 = 0., 0., 1., 45.
###############################################
ball = pt.Particle("Ball", x0, y0, v0, a0)
print(ball)
# implement Euler with a = -g
# compare to algebraic solution
# x = x0 + v0x * t
# y = y0 + v0y * t +
# Revisar Fotos para implementar tarea
xpos = []
ypos = []
tpos = []
xana = []
yana = []
def exact(ball, xpos, ypos, tposReference):
for t in tposReference:
x, y = analytic_solution(t, ball.v0, ball.a0)
xpos.append(x)
ypos.append(y)
#Initial Variables and Lists
m, x0, y0, v0, a0 = 1., 0., 0., 1., 45
deltat = 0.01
sim_params = m, pt.G, pt.DRAG
ball = pt.Particle("Pelota 1", x0, y0, v0, a0, m)
ball_force = fr.Forces(resistive_falling, sim_params)
ball.set_force(ball_force)
ball2 = pt.Particle("Pelota 2", x0, y0, v0, a0, m)
ball2.set_force(ball_force)
ball3 = pt.Particle("Pelota 3", x0, y0, v0, a0, m)
ball3.set_force(ball_force)
ball4 = pt.Particle("Pelota 4", x0, y0, v0, a0, m)
ball4.set_force(ball_force)
xposEuler = []
yposEuler = []
tposEuler = []
deltat = 0.01 / 1024
m1 = "Euler"
m2 = "Euler-Cromer"
m3 = "Midpoint"
infoelipses = []
x0 = 1.
vy0 = 1.
for i in range(200):
print("cond ini, x0 & vy0 =", round(x0, 2))
v0 = vy0
x0, y0, v0, a0, m = x0, .0, v0, 90., 1.
earth = pt.Particle("Earth", x0, y0, v0, a0, m)
# print(earth)
earth_force = fr.Forces(universal_gravity, sim_params)
earth.set_force(earth_force)
euler = sl.Solver(earth, m2, deltat)
xpos, ypos, tpos = [], [], []
cont = 0
for i in range(200000):
xc, yc, vxc, vyc, tc = earth.get_state()
# if tc > 0.415:
# break
xpos.append(xc)
ypos.append(yc)
tpos.append(tc)
euler.do_step()
m, x0, y0, v0, a0 = 1., 1., 0., 5, 90
delta_sim_1 = 0.001
delta_sim_2 = 0.005
delta_sim_3 = 0.01
delta_sim_4 = 0.05
delta_sim_5 = 0.1
sim_params_1 = pt.GM, delta_sim_1
sim_params_2 = pt.GM, delta_sim_2
sim_params_3 = pt.GM, delta_sim_3
sim_params_4 = pt.GM, delta_sim_4
sim_params_5 = pt.GM, delta_sim_5
planet_1 = pt.Particle("Planet Y", x0, y0, v0, a0, m)
planet_1.set_force(fr.Forces(grav_force, sim_params_1))
planet_2 = pt.Particle("Planet Y", x0, y0, v0, a0, m)
planet_2.set_force(fr.Forces(grav_force, sim_params_2))
planet_3 = pt.Particle("Planet Y", x0, y0, v0, a0, m)
planet_3.set_force(fr.Forces(grav_force, sim_params_3))
planet_4 = pt.Particle("Planet Y", x0, y0, v0, a0, m)
planet_4.set_force(fr.Forces(grav_force, sim_params_4))
planet_5 = pt.Particle("Planet Y", x0, y0, v0, a0, m)
planet_5.set_force(fr.Forces(grav_force, sim_params_5))
t = []
