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 = []