def determine_stability_time(tend, Nsteps, N, masses, semimajor_axes, eccentricities, inclinations, APs, LANs, radii): particles = Tools.create_nested_multiple(N, masses, semimajor_axes, eccentricities, inclinations, APs, LANs, radii=radii) orbits = [x for x in particles if x.is_binary == True] for o in orbits: o.check_for_physical_collision_or_orbit_crossing = True N_orbits = len(orbits) #binaries[0].include_pairwise_1PN_terms = True code = SecularMultiple() ### initialize the code code.add_particles(particles) primary = code.particles[0] code.enable_tides = False code.enable_root_finding = True a_AU_print = [[] for x in range(N_orbits)] e_print = [[] for x in range(N_orbits)] INCL_print = [[] for x in range(N_orbits)] rel_INCL_print = [[] for x in range(N_orbits)] t_print = [] t = 0.0 dt = tend / float(Nsteps) import time start = time.time() while t < tend: t += dt code.evolve_model(t) #print 't',t,'es',[o.e for o in orbits] for i in range(N_orbits): rel_INCL_print[i].append(orbits[i].INCL_parent) a_AU_print[i].append(orbits[i].a) e_print[i].append(orbits[i].e) INCL_print[i].append(orbits[i].INCL) t_print.append(t) if code.flag == 2: t = code.model_time #print 'root found at t=',t break #print 'wall time',time.time()-start code.reset() return t
def example1(self): """ Example of a three-planet system with tides in the innermost planet System parameters taken from http://adsabs.harvard.edu/abs/2011ApJ...735..109W Units used in SecularMultiple: length -- AU time -- yr mass -- MSun """ code = SecularMultiple() ### initialize the code CONST_G = code.CONST_G ### extract physical constants from the code CONST_C = code.CONST_C CONST_R_SUN = code.CONST_R_SUN RJup = 0.1027922358015816 * CONST_R_SUN MJup = 0.0009546386983890755 day = 1.0 / 365.25 second = day / (24.0 * 3600.0) N = 4 m0 = 1.0 m1 = 0.5 * MJup m2 = MJup m3 = 1.5 * MJup a1 = 1.0 a2 = 6.0 a3 = 16.0 e1 = 0.066 e2 = 0.188 e3 = 0.334 i1 = 4.5 * np.pi / 180.0 i2 = 19.9 * np.pi / 180.0 i3 = 7.9 * np.pi / 180.0 AP1 = np.pi AP2 = 0.38 * np.pi AP3 = np.pi LAN1 = 0.01 LAN2 = np.pi LAN3 = 0.01 R0 = 1.0 * CONST_R_SUN R1 = 1.0 * RJup R2 = 1.0 * RJup R3 = 1.0 * RJup masses = [m0, m1, m2, m3] radii = [R0, R1, R2, R3] semimajor_axes = [a1, a2, a3] eccentricities = [e1, e2, e3] inclinations = [i1, i2, i3] APs = [AP1, AP2, AP3] LANs = [LAN1, LAN2, LAN3] particles = Tools.create_nested_multiple(N, masses, semimajor_axes, eccentricities, inclinations, APs, LANs, radii=radii) orbits = [x for x in particles if x.is_binary == True] N_orbits = len(orbits) particles[1].spin_vec_x = 0.0 particles[1].spin_vec_y = 0.0 particles[1].spin_vec_z = 4.0e-2 / day k_L = 0.38 k_AM = k_L / 2.0 rg = 0.25 tau = 0.66 * second #I = rg*M*R**2 #alpha = I/(mu*a0**2) T = R1**3 / (CONST_G * m1 * tau) t_V = 3.0 * (1.0 + 1.0 / k_L) * T #print 't_V',t_V,'M',M,'R',R particles[0].include_tidal_friction_terms = False particles[1].tides_method = 1 particles[1].include_tidal_friction_terms = True particles[1].include_tidal_bulges_precession_terms = False particles[1].include_rotation_precession_terms = False particles[1].minimum_eccentricity_for_tidal_precession = 1.0e-8 particles[1].tides_apsidal_motion_constant = k_AM particles[1].tides_viscous_time_scale = t_V particles[1].tides_gyration_radius = rg #binaries[0].include_1PN_terms = True code.add_particles(particles) primary = code.particles[0] code.enable_tides = True code.enable_root_finding = True a_AU_print = [[] for x in range(N_orbits)] e_print = [[] for x in range(N_orbits)] INCL_print = [[] for x in range(N_orbits)] rel_INCL_print = [[] for x in range(N_orbits)] t_print = [] t = 0.0 Nsteps = 2000 tend = 3.0e8 dt = tend / float(Nsteps) import time start = time.time() while t <= tend: code.evolve_model(t) t += dt print('t', t, 'es', [o.e for o in orbits]) for i in range(N_orbits): rel_INCL_print[i].append(orbits[i].INCL_parent) a_AU_print[i].append(orbits[i].a) e_print[i].append(orbits[i].e) INCL_print[i].append(orbits[i].INCL) t_print.append(t) print('wall time', time.time() - start) t_print = np.array(t_print) for i in range(N_orbits): INCL_print[i] = np.array(INCL_print[i]) rel_INCL_print[i] = np.array(rel_INCL_print[i]) e_print[i] = np.array(e_print[i]) a_AU_print[i] = np.array(a_AU_print[i]) from matplotlib import pyplot fig = pyplot.figure(figsize=(8, 8)) plot1 = fig.add_subplot(2, 1, 1, yscale="log") plot2 = fig.add_subplot(2, 1, 2, yscale="linear") colors = ['k', 'r', 'g'] for i in range(N_orbits): color = colors[i] plot1.plot(1.0e-6 * t_print, a_AU_print[i], color=color) plot1.plot(1.0e-6 * t_print, a_AU_print[i] * (1.0 - e_print[i]), color=color) plot1.plot(1.0e-6 * t_print, a_AU_print[i] * (1.0 + e_print[i]), color=color) plot2.plot(1.0e-6 * t_print, INCL_print[i] * 180.0 / np.pi, color=color) plot1.set_xlabel("$t/\mathrm{Myr}$") plot2.set_xlabel("$t/\mathrm{Myr}$") plot1.set_ylabel("$r_i/\mathrm{AU}$") plot2.set_ylabel("$\mathrm{incl}_i/\mathrm{deg}$") fig.savefig("example1.pdf") pyplot.show()
def example2(self): """ Lidov-Kozai problem of a planet around a star around a supermassive black hole. Includes perturbations from other stars in the form of vector resonant relaxation (VRR) """ code = SecularMultiple() ### initialize the code CONST_G = code.CONST_G ### extract physical constants from the code CONST_C = code.CONST_C CONST_R_SUN = code.CONST_R_SUN RJup = 0.1027922358015816 * CONST_R_SUN MJup = 0.0009546386983890755 day = 1.0 / 365.25 second = day / (24.0 * 3600.0) meter = 1.0 / 1.496e+11 ### Input parameters ### m1 = 1.0 m2 = MJup m3 = 4.0e6 a1 = 1.0e-1 a2 = 1.0e4 e1 = 0.01 e2 = 0.1 i1 = 4.5 * np.pi / 180.0 i2 = 19.9 * np.pi / 180.0 AP1 = np.pi AP2 = 0.38 * np.pi LAN1 = 0.01 LAN2 = np.pi R1 = 1.0 * CONST_R_SUN R2 = 1.0 * RJup R3 = CONST_G * m3 / (CONST_C**2) m_star = 1.0 gamma = 3.0 / 2.0 VRR_model = 3 ### Simulation parameters ### VRR_include_mass_precession = True include_inner_1PN_terms = True include_outer_1PN_terms = True ### Process parameters ### P1 = 2.0 * np.pi * np.sqrt(a1**3 / (CONST_G * (m1 + m2))) P2 = 2.0 * np.pi * np.sqrt(a2**3 / (CONST_G * (m1 + m2 + m3))) masses = [m1, m2, m3] radii = [R1, R2, R3] semimajor_axes = [a1, a2] eccentricities = [e1, e2] inclinations = [i1, i2] APs = [AP1, AP2] LANs = [LAN1, LAN2] N = len(masses) particles = Tools.create_nested_multiple(N, masses, semimajor_axes, eccentricities, inclinations, APs, LANs, radii=radii) orbits = [x for x in particles if x.is_binary == True] N_orbits = len(orbits) inner_orbit = orbits[0] outer_orbit = orbits[1] c1 = 4.8 c2 = -2.9 log10_sigma_h_km_s = (np.log10(m3) - c2) / c1 sigma_h_km_s = pow(10.0, log10_sigma_h_km_s) sigma_h = 1.0e3 * sigma_h_km_s * meter / second print('sigma_h_km_s', sigma_h_km_s, 'sigma_h', sigma_h) # K_12 = K_12_function(gamma) # K_32 = K_32_function(gamma) # C_NRR = ((3.0*numpy.pi)/(64.0))*1.0/( K_12 - (1.0/5.0)*K_32 + (5.0*numpy.pi/8.0)*(1.0/(2.0*gamma-1.0)) ) r_h = CONST_G * m3 * (1.0 / (sigma_h**2 * (1.0 + gamma))) * (1.0 + (1.0 + gamma) / (gamma - 1.0)) r_0 = r_h n_0 = (2.0 * m3 / m_star) * ((3.0 - gamma) / (4.0 * np.pi * r_h**3)) r = a2 rho_star = compute_rho_star_r(r, gamma, n_0, r_0, m_star) n_star = compute_n_star_r(r, gamma, n_0, r_0, m_star) M_star = compute_M_star_r(r, gamma, n_0, r_0, m_star) N_star = compute_N_star_r(r, gamma, n_0, r_0, m_star) sigma_r = compute_sigma_r(r, gamma, n_0, r_0, m_star, m3, CONST_G) print('n_star', n_star, 'M_star', M_star, 'N_star', N_star, 'sigma_r', sigma_r) LK_timescale = (P2**2 / P1) * ( (m1 + m2 + m3) / m3) * pow(1.0 - e2**2, 3.0 / 2.0) print('LK_timescale', LK_timescale) VRR_mass_precession_timescale = (1.0 / 2.0) * pow( 1.0 - e2**2, -1.0 / 2.0) * (m3 / M_star) * P2 VRR_mass_precession_rate = 1.0 / VRR_mass_precession_timescale VRR_timescale = (P2 / 2.0) * (m3 / m_star) * 1.0 / np.sqrt(N_star) #VRR_timescale *= 0.1 print('VRR_mass_precession_timescale', VRR_mass_precession_timescale, 'VRR_timescale', VRR_timescale) outer_orbit.VRR_include_mass_precession = VRR_include_mass_precession outer_orbit.VRR_mass_precession_rate = VRR_mass_precession_rate VRR_reorientation_timestep = np.sqrt(0.1) * VRR_timescale print('VRR_reorientation_timestep', VRR_reorientation_timestep) outer_orbit.VRR_model = VRR_model reorientation_function(VRR_model, VRR_timescale, VRR_reorientation_timestep, outer_orbit) v_bin = np.sqrt(CONST_G * (m1 + m2) / a1) q_sigma = (m1 + m2) / m_star log_Lambda = np.log(3.0 * ((1.0 + 1.0 / q_sigma) / (1.0 + 2.0 / q_sigma)) * sigma_r**2 / v_bin**2) evaporation_timescale = np.sqrt( (1.0 + q_sigma) / (2.0 * np.pi * q_sigma)) * (m1 + m2) * sigma_r / (8.0 * np.sqrt( np.pi) * CONST_G * a1 * m_star**2 * n_star * log_Lambda) print('evaporation_timescale', evaporation_timescale) inner_orbit.include_1PN_terms = include_inner_1PN_terms outer_orbit.include_1PN_terms = include_outer_1PN_terms code.add_particles(particles) primary = code.particles[0] code.enable_tides = False code.enable_root_finding = True code.enable_VRR = True a_AU_print = [[] for x in range(N_orbits)] e_print = [[] for x in range(N_orbits)] INCL_print = [[] for x in range(N_orbits)] rel_INCL_print = [[] for x in range(N_orbits)] t_print = [] t = 0.0 Nsteps = 1000 tend = evaporation_timescale dt_fixed = tend / float(Nsteps) t_next_reorientation = VRR_reorientation_timestep import time start = time.time() while t <= tend: dt = dt_fixed if t + dt > t_next_reorientation: dt = t_next_reorientation - t t_next_reorientation += VRR_reorientation_timestep reorientation_function(VRR_model, VRR_timescale, t_next_reorientation, outer_orbit) t += dt code.evolve_model(t) print('t', t, 'es', [o.e for o in orbits], 'Omegas', [o.LAN for o in orbits]) for i in range(N_orbits): rel_INCL_print[i].append(orbits[i].INCL_parent) a_AU_print[i].append(orbits[i].a) e_print[i].append(orbits[i].e) INCL_print[i].append(orbits[i].INCL) t_print.append(t) print('wall time', time.time() - start) t_print = np.array(t_print) for i in range(N_orbits): INCL_print[i] = np.array(INCL_print[i]) rel_INCL_print[i] = np.array(rel_INCL_print[i]) e_print[i] = np.array(e_print[i]) a_AU_print[i] = np.array(a_AU_print[i]) from matplotlib import pyplot fig = pyplot.figure(figsize=(8, 8)) plot1 = fig.add_subplot(2, 1, 1, yscale="log") plot2 = fig.add_subplot(2, 1, 2, yscale="linear") colors = ['k', 'r', 'g'] for i in range(N_orbits): color = colors[i] plot1.plot(1.0e-6 * t_print, a_AU_print[i], color=color) plot1.plot(1.0e-6 * t_print, a_AU_print[i] * (1.0 - e_print[i]), color=color) plot1.plot(1.0e-6 * t_print, a_AU_print[i] * (1.0 + e_print[i]), color=color) #plot2.plot(1.0e-6*t_print,INCL_print[i]*180.0/np.pi,color=color,linestyle='dotted') plot2.plot(1.0e-6 * t_print, rel_INCL_print[i] * 180.0 / np.pi, color=color) plot1.set_xlabel("$t/\mathrm{Myr}$") plot2.set_xlabel("$t/\mathrm{Myr}$") plot1.set_ylabel("$r_i/\mathrm{AU}$") plot2.set_ylabel("$\mathrm{incl}_\mathrm{rel}/\mathrm{deg}$") fig.savefig("example2.pdf") pyplot.show()
def example3(self, args): m1 = 1.0 m2 = 1.0e-6 m3 = 1.0 e1 = 0 e2 = 0.4 a1 = 1.0 a2 = 10.0 i1 = 0.2 i2 = 65.0 * np.pi / 180.0 AP1 = 0 AP2 = 0 LAN1 = 0 LAN2 = 0 do_nbody = True particles = Tools.create_nested_multiple(3, [m1, m2, m3], [a1, a2], [e1, e2], [i1, i2], [AP1, AP2], [LAN1, LAN2]) bodies = [x for x in particles if x.is_binary == False] binaries = [x for x in particles if x.is_binary == True] N_binaries = len(binaries) N_bodies = len(bodies) code = SecularMultiple() code.add_particles(particles) CONST_G = code.CONST_G P1 = 2.0 * np.pi * np.sqrt(a1**3 / (CONST_G * (m1 + m2))) P2 = 2.0 * np.pi * np.sqrt(a2**3 / (CONST_G * (m1 + m2 + m3))) P_LK12 = (P2**2 / P1) * ( (m1 + m2 + m3) / m3) * pow(1.0 - e2**2, 3.0 / 2.0) if args.verbose == True: print("Ps", P1 * 1e-6, P2 * 1e-6) print("P_LKs", P_LK12 * 1e-6) N = 5000 tend = 1.e4 integration_methods = [[0, 0], [0, 1]] #integration_methods = [0,0,0] KS_use_V = [[True, True], [True, True]] #KS_use_V = [True,True,False] terms = [[False, True, True, True, True, True], [False, True, True, True, True, True]] import time data_arrays = [] for index_combination, integration_method in enumerate( integration_methods): if args.verbose == True: print("index_combination", index_combination) particles = Tools.create_nested_multiple(3, [m1, m2, m3], [a1, a2], [e1, e2], [i1, i2], [AP1, AP2], [LAN1, LAN2]) bodies = [x for x in particles if x.is_binary == False] binaries = [x for x in particles if x.is_binary == True] binaries[0].integration_method = integration_methods[ index_combination][0] binaries[1].integration_method = integration_methods[ index_combination][1] binaries[0].KS_use_perturbing_potential = KS_use_V[ index_combination][0] binaries[1].KS_use_perturbing_potential = KS_use_V[ index_combination][1] code = SecularMultiple() code.add_particles(particles) code.enable_root_finding = True binaries[0].check_for_physical_collision_or_orbit_crossing = True bodies[0].radius = 1.0e-5 bodies[1].radius = 1.0e-5 code.include_double_averaging_corrections = terms[ index_combination][0] code.include_quadrupole_order_terms = terms[index_combination][1] code.include_octupole_order_binary_pair_terms = terms[ index_combination][2] code.include_octupole_order_binary_triplet_terms = terms[ index_combination][3] code.include_hexadecupole_order_binary_pair_terms = terms[ index_combination][4] code.include_dotriacontupole_order_binary_pair_terms = terms[ index_combination][5] if args.verbose == True: print("Integration methods ", [x.integration_method for x in binaries], "KS_V", [x.KS_use_perturbing_potential for x in binaries], "terms", code.include_double_averaging_corrections, code.include_quadrupole_order_terms, code.include_octupole_order_binary_pair_terms, code.include_octupole_order_binary_triplet_terms, code.include_hexadecupole_order_binary_pair_terms, code.include_dotriacontupole_order_binary_pair_terms) a_print = [[] for x in range(N_binaries)] e_print = [[] for x in range(N_binaries)] i_print = [[] for x in range(N_binaries)] rel_INCL_print = [[] for x in range(N_binaries)] t_print = [] start = time.time() t = 0.0 dt = tend / float(N) while t < tend: t += dt code.evolve_model(t) if args.verbose == True: print('t', t, 'es', [o.e for o in binaries]) for i in range(N_binaries): a_print[i].append([binaries[i].a]) e_print[i].append([binaries[i].e]) i_print[i].append(binaries[i].INCL) rel_INCL_print[i].append(binaries[i].INCL_parent) t_print.append(t) wall_time = time.time() - start code.reset() t_print = np.array(t_print) for i in range(N_binaries): a_print[i] = np.array(a_print[i]) e_print[i] = np.array(e_print[i]) i_print[i] = np.array(i_print[i]) data = { 't_print': t_print, 'a_print': a_print, 'e_print': e_print, 'i_print': i_print, 'wall_time': wall_time, 'integration_methods': integration_methods[index_combination], 'KS_use_perturbing_potential': KS_use_V[index_combination], 'terms': terms[index_combination] } data_arrays.append(data) if HAS_MATPLOTLIB == True and args.plot == True: linestyles = ['solid', 'dotted', 'dashed', '-.'] linewidth = 2.0 fig = pyplot.figure(figsize=(8, 8)) plot1 = fig.add_subplot(2, 1, 1, yscale="linear") plot2 = fig.add_subplot(2, 1, 2, yscale="log") linewidths = [1.5, 2.5, 1.5] colors = ['k', 'tab:red', 'tab:orange'] for index_combination, data in enumerate(data_arrays): linewidth = linewidths[index_combination] linestyle = linestyles[index_combination] N_binaries = len(data["a_print"]) color = colors[index_combination] if index_combination == 0: label = "$\mathrm{Double\,averaged; \,WT=%s\,s}$" % round( data["wall_time"], 1) elif index_combination == 1: label = "$\mathrm{Single\,averaged; \,WT=%s\,s}$" % round( data["wall_time"], 1) for i in range(N_binaries): if i != 0: label = "" label_nb = "" plot1.plot(1.0e-6 * data["t_print"], data["i_print"][i] * 180.0 / np.pi, color=color, linestyle=linestyle, linewidth=linewidth) plot2.plot(1.0e-6 * data["t_print"], 1.0 - data["e_print"][i], color=color, linestyle=linestyle, linewidth=linewidth, label=label) fontsize = 18 labelsize = 18 plot1.set_ylabel("$i_\mathrm{}\,(\mathrm{deg})$", fontsize=fontsize) plot2.set_ylabel("$1-e$", fontsize=fontsize) plot2.set_xlabel("$t/\mathrm{Myr}$", fontsize=fontsize) plots = [plot1, plot2] for plot in plots: plot.tick_params(axis='both', which='major', labelsize=labelsize, bottom=True, top=True, left=True, right=True) plot2.set_ylim(5e-4, 1.1e0) plot1.set_xticklabels([]) ticks = plot1.get_yticks() plot1.set_yticks(ticks[2::]) handles, labels = plot2.get_legend_handles_labels() plot2.legend(handles, labels, loc="lower left", fontsize=0.8 * fontsize) fig.subplots_adjust(hspace=0.0, wspace=0.0) fig.savefig("example3.pdf") if args.show == True: pyplot.show()
def run_simulation(tend,Nsteps,particles, \ VRR_reorientation_timestep,VRR_model,VRR_timescale,outer_orbit, \ enable_tides=False,enable_root_finding=True,enable_VRR=True): code = SecularMultiple() ### initialize the code code.add_particles(particles) primary = code.particles[0] code.enable_tides = enable_tides code.enable_root_finding = enable_root_finding code.enable_VRR = enable_VRR orbits = [x for x in particles if x.is_binary == True] N_orbits = len(orbits) a_AU_print = [[] for x in range(N_orbits)] e_print = [[] for x in range(N_orbits)] rp_AU_print = [[] for x in range(N_orbits)] INCL_print = [[] for x in range(N_orbits)] rel_INCL_print = [[] for x in range(N_orbits)] t_print = [] t = 0.0 dt_fixed = tend / float(Nsteps) t_next_reorientation = VRR_reorientation_timestep found_root = False import time start = time.time() while t <= tend: dt = dt_fixed if t + dt > t_next_reorientation: dt = t_next_reorientation - t t_next_reorientation += VRR_reorientation_timestep reorientation_function(VRR_model, VRR_timescale, t_next_reorientation, outer_orbit) t += dt code.evolve_model(t) #print 't',t,'es',[o.e for o in orbits],'Omegas',[o.LAN for o in orbits] if code.flag == 2: t = code.model_time print 'root found at t=', t found_root = True for i in range(N_orbits): rel_INCL_print[i].append(orbits[i].INCL_parent) a_AU_print[i].append(orbits[i].a) e_print[i].append(orbits[i].e) INCL_print[i].append(orbits[i].INCL) rp_AU_print[i].append(orbits[i].a * (1.0 - orbits[i].e)) t_print.append(t) if found_root == True: break print 'wall time', time.time() - start t_print = np.array(t_print) for i in range(N_orbits): INCL_print[i] = np.array(INCL_print[i]) rel_INCL_print[i] = np.array(rel_INCL_print[i]) e_print[i] = np.array(e_print[i]) a_AU_print[i] = np.array(a_AU_print[i]) rp_AU_print[i] = np.array(rp_AU_print[i]) code.reset() data = found_root, t_print, rel_INCL_print, e_print, a_AU_print, rp_AU_print return data
def example2(self): """ Example of an (N-1)-planet system with constant spacing in mutual Hill sphere """ code = SecularMultiple() ### initialize the code CONST_G = code.CONST_G ### extract physical constants from the code CONST_C = code.CONST_C CONST_R_SUN = code.CONST_R_SUN RJup = 0.1027922358015816 * CONST_R_SUN MJup = 0.0009546386983890755 day = 1.0 / 365.25 second = day / (24.0 * 3600.0) N = 5 m0 = 1.0 R0 = CONST_R_SUN a1 = 1.0 mp = MJup Rp = RJup ei = 0.28 ii = ei APi = 1.0e-10 ### arguments of periapsis LANi = 1.0e-10 ### longitudes of ascending node X = (1.0 / 2.0) * pow(2.0 * mp / (3.0 * m0), 1.0 / 3.0) Delta = 10.0 Delta_min = ei / X print 'Delta_min', Delta_min Nsteps = 100 tend = 1.0e6 masses = [m0] radii = [R0] semimajor_axes = [] eccentricities = [] inclinations = [] APs = [] LANs = [] ai = a1 for i in range(N - 1): masses.append(mp) radii.append(Rp) ai = ai * (1.0 + Delta * X) / (1.0 - Delta * X) semimajor_axes.append(ai) eccentricities.append(ei) inclinations.append(ii) APs.append(APi) LANs.append(LANi) print 'test', masses, semimajor_axes, eccentricities particles = Tools.create_nested_multiple(N, masses, semimajor_axes, eccentricities, inclinations, APs, LANs, radii=radii) orbits = [x for x in particles if x.is_binary == True] for o in orbits: o.check_for_physical_collision_or_orbit_crossing = True N_orbits = len(orbits) #orbits[0].include_pairwise_1PN_terms = True code.add_particles(particles) primary = code.particles[0] code.enable_tides = False code.enable_root_finding = True a_AU_print = [[] for x in range(N_orbits)] e_print = [[] for x in range(N_orbits)] INCL_print = [[] for x in range(N_orbits)] rel_INCL_print = [[] for x in range(N_orbits)] t_print = [] t = 0.0 dt = tend / float(Nsteps) import time start = time.time() while t <= tend: code.evolve_model(t) print 't', t, 'es', [o.e for o in orbits] for i in range(N_orbits): rel_INCL_print[i].append(orbits[i].INCL_parent) a_AU_print[i].append(orbits[i].a) e_print[i].append(orbits[i].e) INCL_print[i].append(orbits[i].INCL) t_print.append(t) if code.flag == 2: t = code.model_time print 'root found at t=', t break t += dt print 'wall time', time.time() - start t_print = np.array(t_print) for i in range(N_orbits): INCL_print[i] = np.array(INCL_print[i]) rel_INCL_print[i] = np.array(rel_INCL_print[i]) e_print[i] = np.array(e_print[i]) a_AU_print[i] = np.array(a_AU_print[i]) from matplotlib import pyplot fig = pyplot.figure(figsize=(8, 8)) plot1 = fig.add_subplot(2, 1, 1, yscale="log") plot2 = fig.add_subplot(2, 1, 2, yscale="linear") colors = ['k', 'r', 'g', 'y', 'b'] for i in range(N_orbits): color = colors[i] plot1.plot(1.0e-6 * t_print, a_AU_print[i], color=color) plot1.plot(1.0e-6 * t_print, a_AU_print[i] * (1.0 - e_print[i]), color=color) plot1.plot(1.0e-6 * t_print, a_AU_print[i] * (1.0 + e_print[i]), color=color) plot2.plot(1.0e-6 * t_print, INCL_print[i] * 180.0 / np.pi, color=color) plot1.set_xlabel("$t/\mathrm{Myr}$") plot2.set_xlabel("$t/\mathrm{Myr}$") plot1.set_ylabel("$r_i/\mathrm{AU}$") plot2.set_ylabel("$\mathrm{incl}_i/\mathrm{deg}$") fig.savefig("example2.pdf") pyplot.show()