def integrate_solar_system(particles, end_time):
from amuse.lab import Huayno, nbody_system
from amuse.units import quantities
convert_nbody = nbody_system.nbody_to_si(particles.mass.sum(), particles[1].position.length())
gravity = Huayno(convert_nbody)
gravity.particles.add_particles(particles)
venus = gravity.particles[1]
earth = gravity.particles[2]
x_earth = [] | units.AU
y_earth = [] | units.AU
x_venus = [] | units.AU
y_venus = [] | units.AU
while gravity.model_time < end_time:
gravity.evolve_model(gravity.model_time + (10 | units.day))
x_earth.append(earth.x)
y_earth.append(earth.y)
x_venus.append(venus.x)
y_venus.append(venus.y)
# from amuse.lab import *
# write_set_to_file(gravity.particles, "gravity.h5", "hdf5")
gravity.stop()
return x_earth, y_earth, x_venus, y_venus
def integrate_solar_system(particles, end_time):
from amuse.units import constants, units
#print(particles)
#convert_body = nbody_system.nbody_to_si(particles.mass.sum(),
# particles[1].position.length())
gravity = Huayno()
gravity.particles.add_particles(particles)
sun = gravity.particles[0]
venus = gravity.particles[1]
earth = gravity.particles[2]
x_earth = [] | nbody_system.length
y_earth = [] | nbody_system.length
x_venus = [] | nbody_system.length
y_venus = [] | nbody_system.length
x_sun = [] | nbody_system.length
y_sun = [] | nbody_system.length
while gravity.model_time < end_time:
gravity.evolve_model(gravity.model_time + (0.001 | nbody_system.time))
x_sun.append(sun.x)
y_sun.append(sun.y)
x_earth.append(earth.x)
y_earth.append(earth.y)
x_venus.append(venus.x)
y_venus.append(venus.y)
gravity.stop()
return x_earth, y_earth, x_venus, y_venus, x_sun, y_sun
def integrate_solar_system(particles, end_time):
from amuse.lab import Huayno, nbody_system
from amuse.units.generic_unit_converter import ConvertBetweenGenericAndSiUnits
from amuse.units import constants, units
#print(particles)
#converter_body = nbody_system.nbody_to_si(particles.mass.sum(),
# particles[1].position.length())
converter_body = nbody_system.nbody_to_si(1 | units.kg, 1 | units.m)
#print(convert_nbody)
#converter = ConvertBetweenGenericAndSiUnits(particles)#????????????????????
#gravity = Huayno(converter.to_si(particles))
gravity = Huayno(converter_body)
gravity.particles.add_particles(particles)
sun = gravity.particles[0]
venus = gravity.particles[1]
earth = gravity.particles[2]
x_earth = [] | units.m
y_earth = [] | units.m
x_venus = [] | units.m
y_venus = [] | units.m
x_sun = [] | units.m
y_sun = [] | units.m
while gravity.model_time < end_time:
gravity.evolve_model(gravity.model_time + (1 | units.s))
x_sun.append(sun.x)
y_sun.append(sun.y)
x_earth.append(earth.x)
y_earth.append(earth.y)
x_venus.append(venus.x)
y_venus.append(venus.y)
gravity.stop()
return x_earth, y_earth, x_venus, y_venus, x_sun, y_sun
def integrate_solar_system(particles, end_time):
from amuse.lab import Huayno, nbody_system
convert_nbody = nbody_system.nbody_to_si(particles.mass.sum(),
particles[1].position.length())
gravity = Huayno(convert_nbody)
gravity.particles.add_particles(particles)
venus = gravity.particles[1]
earth = gravity.particles[2]
x_earth = [] | units.AU
y_earth = [] | units.AU
x_venus = [] | units.AU
y_venus = [] | units.AU
while gravity.model_time < end_time:
gravity.evolve_model(gravity.model_time + (1 | units.day))
x_earth.append(earth.x)
y_earth.append(earth.y)
x_venus.append(venus.x)
y_venus.append(venus.y)
gravity.stop()
return x_earth, y_earth, x_venus, y_venus
def integrate_solar_system():
# Get initial conditions.
solar = planetary_system()[0]
debris = planetary_system()[1]
star = solar[0]
planet = solar[1]
moon = solar[2]
# Integrators set to Huayno.
converter = nbody_system.nbody_to_si(star.mass, 1. | units.AU)
system_gravity = Huayno(converter)
system_gravity.particles.add_particle(star)
system_gravity.particles.add_particle(planet)
system_gravity.particles.add_particle(moon)
disk_gravity = Huayno(converter)
disk_gravity.particles.add_particle(debris)
# Set up channels.
channel_from_system_to_framework = system_gravity.particles.new_channel_to(
solar)
channel_from_disk_to_framework = disk_gravity.particles.new_channel_to(
debris)
# Set up bridge.
gravity = bridge.Bridge(use_threading=False, method=SPLIT_4TH_S_M4)
gravity.add_system(system_gravity, (disk_gravity, ))
gravity.add_system(disk_gravity, (system_gravity, ))
# Record positions.
x_planet = quantities.AdaptingVectorQuantity()
y_planet = quantities.AdaptingVectorQuantity()
x_moon = quantities.AdaptingVectorQuantity()
y_moon = quantities.AdaptingVectorQuantity()
x_debris = quantities.AdaptingVectorQuantity()
y_debris = quantities.AdaptingVectorQuantity()
# Evolving time.
t = 0 | units.day
dt = 1 | units.day # to make sure getting 250 snapshots
t_end = 1 | units.yr # 29.4571 yr Saturn's orbital period
# Record time and energies.
time = quantities.AdaptingVectorQuantity()
system_E = quantities.AdaptingVectorQuantity()
disk_E = quantities.AdaptingVectorQuantity()
bridge_E = quantities.AdaptingVectorQuantity()
# Evolve model.
print 'Begin evolving'
while t < t_end:
t += dt
gravity.evolve_model(t)
channel_from_system_to_framework.copy()
channel_from_disk_to_framework.copy()
x_planet.append(planet.x)
y_planet.append(planet.y)
x_moon.append(moon.x)
y_moon.append(moon.y)
x_debris.append(debris.x)
y_debris.append(debris.y)
time.append(t)
system_E.append(system_gravity.kinetic_energy +
system_gravity.potential_energy)
disk_E.append(disk_gravity.kinetic_energy +
disk_gravity.potential_energy)
bridge_E.append(gravity.kinetic_energy + gravity.potential_energy)
pyplot.clf()
pyplot.xlabel('x [au]')
pyplot.ylabel('y [au]')
#pyplot.xlim(-2.2, -1.9)
#pyplot.ylim(8.7, 8.8)
pyplot.scatter(star.x.value_in(units.AU),
star.y.value_in(units.AU),
color='black',
label='star')
pyplot.scatter(planet.x.value_in(units.AU),
planet.y.value_in(units.AU),
color='blue',
label='planet')
pyplot.scatter(moon.x.value_in(units.AU),
moon.y.value_in(units.AU),
color='red',
label='moon')
pyplot.scatter(debris.x.value_in(units.AU),
debris.y.value_in(units.AU),
color='green',
s=1,
label='disk')
#pyplot.legend()
pyplot.savefig(
'/home/rywang/capexam/plots/animation/positions_{0:03}.png'.format(
t.number))
print 'Generating plot{}'.format(t.number)
gravity.stop()
print 'End evolving'
# Making animation.
subprocess.call(
"mencoder 'mf:///home/rywang/capexam/plots/animation/positions_*.png' -mf type=png:fps=20 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o /home/rywang/capexam/plots/animation/animation.mpg",
shell=True)
return time, system_E, disk_E, bridge_E, x_planet, y_planet, x_moon, y_moon, x_debris, y_debris
def MWG_tack_evolver(complete_pre_tack_system, converter, N_objects, times,
save_file_times, potential):
#Initialise the gravity code and add the particles to it
gravity_code = Huayno(converter)
gravity_code.particles.add_particles(complete_pre_tack_system)
channel = gravity_code.particles.new_channel_to(complete_pre_tack_system)
gravity_bridge = 0
gravity_bridge = bridge.Bridge(use_threading=False)
gravity_bridge.add_system(gravity_code, (potential, ))
gravity_bridge.timestep = 100 | units.yr
#----------------------------------------------------------------------------------------------------
#Here we define the 'correct' sma's for the different migrations. Also, the initial
#planetary inclinations are stored for later use.
initial_sma = np.array([3.5, 4.5, 6.013, 8.031]) | units.AU
saturn_sma = np.array([1.5, 4.5, 6.013, 8.031]) | units.AU
outward_sma = np.array([1.5, 1.5 *
((3 / 2)**(2 / 3)), 6.013, 8.031]) | units.AU
post_tack_sma = np.array([5.4, 7.1, 10.5, 13.]) | units.AU
current_sma = [3.5, 4.5, 6.013, 8.031] | units.AU
inclinations = [0, 0, 0, 0] | units.deg
for k in range(4):
orbital_elements = get_orbital_elements_from_binary(
complete_pre_tack_system[0] + complete_pre_tack_system[k + 1],
G=constants.G)
inclinations[k] = orbital_elements[5]
#----------------------------------------------------------------------------------------------------
#Here we define the parameters used in the 'semi_major_axis_next_step' functions
#The sma's are based on exact resonances. The time_scales are taken from literature.
#The 0 values will be changed during the evolution of the model.
#pre_resonant is used in the outward migration, when jupiter and saturn are
#already in resonance with eachother, so that pre_resonant = True
a_start = [1.5, 1.5 * ((3 / 2)**(2 / 3)), 0, 0] | units.AU
a_end = [
5.4, 5.4 * ((3 / 2)**(2 / 3)), 5.4 *
((3 / 2)**(2 / 3) * (9 / 5)**(2 / 3)), 5.4 * ((3 / 2)**(2 / 3) *
(5 / 2)**(2 / 3))
] | units.AU
time_start = [1.025 * 10**5, 1.025 * 10**5, 0, 0] | units.yr
time_scale = [5 * 10**5, 5 * 10**5, 0, 0] | units.yr
resonances = [2 / 3, 3 / 2, 9 / 5, 5 / 2]
pre_resonant = [False, False, True, True]
outward_migration_started = False
dead_comets = []
#----------------------------------------------------------------------------------------------------
#Below, the evolution starts.
for i in tqdm(range(len(times) - 1)):
gravity_code.evolve_model(times[i])
channel.copy()
#Save the model when we want it to
if times[i] in save_file_times:
write_set_to_file(
gravity_code.particles,
directory + 'MWG_Tack_run' + str(run_number) + '_time=' +
str(np.log10(times[i].value_in(units.yr)))[0:5] + '.hdf5',
format='hdf5',
overwrite_file=True)
#For each timestep determine the current sma's
for j in range(4):
current_sma[j] = sma_determinator(gravity_code.particles[0],
gravity_code.particles[j + 1])
#-----------------------------------------------------------------------------------------------------
#This chunk of code describes the inward migration of jupiter
#The first orbiter and the second particle in the gravity_code.
if times[i] < 10**5 | units.yr:
#This pushes Jupiter slightly inward
sma_next_step = semi_major_axis_next_step_in_jup(
times[i + 1], 10**5 | units.yr, 3.5 | units.AU, 1.5 | units.AU)
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[1])
orbital_params = get_orbital_elements_from_binary(binary,
G=constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[4].in_(
units.deg), orbital_params[6].in_(
units.deg), orbital_params[7].in_(units.deg)
sun_and_planet = new_binary_from_orbital_elements(
1 | units.MSun,
orbital_params[1],
sma_next_step,
0,
true_anomaly,
inclinations[0],
ascending_node,
pericenter,
G=constants.G)
gravity_code.particles[1].position = (sun_and_planet[1].x +
gravity_code.particles[0].x,
sun_and_planet[1].y +
gravity_code.particles[0].y,
sun_and_planet[1].z +
gravity_code.particles[0].z)
gravity_code.particles[1].velocity = (sun_and_planet[1].vx +
gravity_code.particles[0].vx,
sun_and_planet[1].vy +
gravity_code.particles[0].vy,
sun_and_planet[1].vz +
gravity_code.particles[0].vz)
#During the tack, the masses of the planets increase towards their current values
gravity_code.particles[2].mass *= 2**(1.5 / (10**5))
gravity_code.particles[3].mass *= 1.2**(1.5 / (10**5))
gravity_code.particles[4].mass *= 1.2**(1.5 / (10**5))
#This keeps the other planets in place
for j in range(3):
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[j + 2])
orbital_params = get_orbital_elements_from_binary(
binary, G=constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[
4].in_(units.deg), orbital_params[6].in_(
units.deg), orbital_params[7].in_(units.deg)
sun_and_planet = new_binary_from_orbital_elements(
1 | units.MSun,
orbital_params[1],
initial_sma[1 + j],
0,
true_anomaly,
inclinations[j + 1],
ascending_node,
pericenter,
G=constants.G)
gravity_code.particles[j + 2].position = (
sun_and_planet[1].x + gravity_code.particles[0].x,
sun_and_planet[1].y + gravity_code.particles[0].y,
sun_and_planet[1].z + gravity_code.particles[0].z)
gravity_code.particles[j + 2].velocity = (
sun_and_planet[1].vx + gravity_code.particles[0].vx,
sun_and_planet[1].vy + gravity_code.particles[0].vy,
sun_and_planet[1].vz + gravity_code.particles[0].vz)
#------------------------------------------------------------------------------------------------------------
#This chunk of code describes the inward migration of saturn
elif 1 * 10**5 | units.yr <= times[i] < 1.025 * 10**5 | units.yr:
#This pushes Saturn slightly inward
sma_next_step = semi_major_axis_next_step_in_sat(
times[i + 1], 2.5 * 10**3 | units.yr, 4.5 | units.AU,
1.5 * ((3 / 2)**(2 / 3)) | units.AU)
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[2])
orbital_params = get_orbital_elements_from_binary(binary,
G=constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[4].in_(
units.deg), orbital_params[6].in_(
units.deg), orbital_params[7].in_(units.deg)
sun_and_planet = new_binary_from_orbital_elements(
1 | units.MSun,
orbital_params[1],
sma_next_step,
0,
true_anomaly,
inclinations[1],
ascending_node,
pericenter,
G=constants.G)
gravity_code.particles[2].position = (sun_and_planet[1].x +
gravity_code.particles[0].x,
sun_and_planet[1].y +
gravity_code.particles[0].y,
sun_and_planet[1].z +
gravity_code.particles[0].z)
gravity_code.particles[2].velocity = (sun_and_planet[1].vx +
gravity_code.particles[0].vx,
sun_and_planet[1].vy +
gravity_code.particles[0].vy,
sun_and_planet[1].vz +
gravity_code.particles[0].vz)
gravity_code.particles[2].mass *= 1.5**(0.5 / (2500))
gravity_code.particles[3].mass *= (17.15 / 6)**(0.5 / (5 * 10**5))
gravity_code.particles[4].mass *= (14.54 / 6)**(0.5 / (5 * 10**5))
#This keeps the other planets in place
for j in [0, 2, 3]:
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[j + 1])
orbital_params = get_orbital_elements_from_binary(
binary, G=constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[
4].in_(units.deg), orbital_params[6].in_(
units.deg), orbital_params[7].in_(units.deg)
sun_and_planet = new_binary_from_orbital_elements(
1 | units.MSun,
orbital_params[1],
saturn_sma[j],
0,
true_anomaly,
inclinations[j],
ascending_node,
pericenter,
G=constants.G)
gravity_code.particles[j + 1].position = (
sun_and_planet[1].x + gravity_code.particles[0].x,
sun_and_planet[1].y + gravity_code.particles[0].y,
sun_and_planet[1].z + gravity_code.particles[0].z)
gravity_code.particles[j + 1].velocity = (
sun_and_planet[1].vx + gravity_code.particles[0].vx,
sun_and_planet[1].vy + gravity_code.particles[0].vy,
sun_and_planet[1].vz + gravity_code.particles[0].vz)
#------------------------------------------------------------------------------------------------------------
#This chunk of code describes the outward migration of all planets
elif 1.025 * 10**5 | units.yr <= times[i] < 6 * 10**5 | units.yr:
#This bit checks if uranus and neptune already should start migrating
for k in range(4):
if pre_resonant[k] == True:
if current_sma[k] / current_sma[1] < (resonances[k])**(2 /
3):
pre_resonant[k] = False
a_start[k] = current_sma[k]
time_start[k] = times[i]
time_scale[k] = (6 * 10**5 | units.yr) - times[i]
#If pre_resonant == False, pushes the planet outward. If true, keeps it in place
for l in range(4):
if pre_resonant[l] == False:
sma_next_step = semi_major_axis_next_step_out(
times[i + 1], time_start[l], a_end[l], a_start[l],
time_scale[l])
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[l + 1])
orbital_params = get_orbital_elements_from_binary(
binary, G=constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[
4].in_(units.deg), orbital_params[6].in_(
units.deg), orbital_params[7].in_(units.deg)
sun_and_planet = new_binary_from_orbital_elements(
1 | units.MSun,
orbital_params[1],
sma_next_step,
0,
true_anomaly,
inclinations[l],
ascending_node,
pericenter,
G=constants.G)
gravity_code.particles[l + 1].position = (
sun_and_planet[1].x + gravity_code.particles[0].x,
sun_and_planet[1].y + gravity_code.particles[0].y,
sun_and_planet[1].z + gravity_code.particles[0].z)
gravity_code.particles[l + 1].velocity = (
sun_and_planet[1].vx + gravity_code.particles[0].vx,
sun_and_planet[1].vy + gravity_code.particles[0].vy,
sun_and_planet[1].vz + gravity_code.particles[0].vz)
else:
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[l + 1])
orbital_params = get_orbital_elements_from_binary(
binary, G=constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[
4].in_(units.deg), orbital_params[6].in_(
units.deg), orbital_params[7].in_(units.deg)
sun_and_planet = new_binary_from_orbital_elements(
1 | units.MSun,
orbital_params[1],
outward_sma[l],
0,
true_anomaly,
inclinations[l],
ascending_node,
pericenter,
G=constants.G)
gravity_code.particles[l + 1].position = (
sun_and_planet[1].x + gravity_code.particles[0].x,
sun_and_planet[1].y + gravity_code.particles[0].y,
sun_and_planet[1].z + gravity_code.particles[0].z)
gravity_code.particles[l + 1].velocity = (
sun_and_planet[1].vx + gravity_code.particles[0].vx,
sun_and_planet[1].vy + gravity_code.particles[0].vy,
sun_and_planet[1].vz + gravity_code.particles[0].vz)
gravity_code.particles[3].mass *= (17.15 / 6)**(15 / (5 * 10**5))
gravity_code.particles[4].mass *= (14.54 / 6)**(15 / (5 * 10**5))
#------------------------------------------------------------------------------------------------------------
#This chunk of code describes the post tack movements of the planets
else:
#---------------------------------------------------------------------------------------------------------------
for l in range(4):
if abs(current_sma[l] / post_tack_sma[l]) > 1.25 or abs(
current_sma[l] / post_tack_sma[l]
) < 0.75: #The orbits are too much perturbed, so we end the simulation
return
elif abs(current_sma[l] / post_tack_sma[l]) > 1.05 or abs(
current_sma[l] / post_tack_sma[l]
) < 0.95: #The orbits are slightly perturbed, so we redefinie them
print("Here", complete_pre_tack_system[l + 1].name,
"was redefined")
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[l + 1])
orbital_params = get_orbital_elements_from_binary(
binary, G=constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[
4].in_(units.deg), orbital_params[6].in_(
units.deg), orbital_params[7].in_(units.deg)
sun_and_planet = new_binary_from_orbital_elements(
1 | units.MSun,
orbital_params[1],
post_tack_sma[l],
0,
true_anomaly,
inclinations[l],
ascending_node,
pericenter,
G=constants.G)
gravity_code.particles[l + 1].position = (
sun_and_planet[1].x + gravity_code.particles[0].x,
sun_and_planet[1].y + gravity_code.particles[0].y,
sun_and_planet[1].z + gravity_code.particles[0].z)
gravity_code.particles[l + 1].velocity = (
sun_and_planet[1].vx + gravity_code.particles[0].vx,
sun_and_planet[1].vy + gravity_code.particles[0].vy,
sun_and_planet[1].vz + gravity_code.particles[0].vz)
else:
pass
if i % 100 == 0:
print(complete_pre_tack_system[l].name, ' is at ',
(gravity_code.particles[l + 1].position -
gravity_code.particles[0].position).length().in_(
units.AU))
#----------------------------------------------------------------------------------------------------------------------
#Here we look for 'escaped' and 'out of bounds' comets
out_of_bounds, escaped_comets = [], []
for i in range(len(gravity_code.particles)):
if (gravity_code.particles[i].position -
gravity_code.particles[0].position
).length() > 500 | units.AU:
escaped_comets.append(gravity_code.particles[i])
if (gravity_code.particles[i].position -
gravity_code.particles[0].position
).length() > 250000 | units.AU:
out_of_bounds.append(gravity_code.particles[i])
dead_comets.append(gravity_code.particles[i])
for particle in out_of_bounds:
complete_pre_tack_system.remove_particle(particle)
complete_pre_tack_system.synchronize_to(gravity_code.particles)
if i % 1000 == 0:
print("The amount of currently escaped comets is ",
len(escaped_comets))
print("The amount of dead comets is ", len(dead_comets))
if i % 1000 == 0:
print("The sma's are: ", current_sma[0], current_sma[1],
current_sma[2], current_sma[3])
gravity_code.stop()
return complete_pre_tack_system
def MWG_evolver(complete_post_tack_system, converter, N_objects, potential, end_time, time_step):
#Initialise the gravity code and add the particles to it
gravity_code = Huayno(converter)
gravity_code.particles.add_particles(complete_post_tack_system)
channel = gravity_code.particles.new_channel_to(complete_post_tack_system)
gravity_bridge = 0
gravity_bridge = bridge.Bridge(use_threading=False)
gravity_bridge.add_system(gravity_code, (potential,))
gravity_bridge.timestep = 100 |units.yr
times = np.arange(0., end_time, time_step) | units.yr #All time steps to which we want to evolve the model
#---------------------------------------------------------------------------------------------------------
#Here we define the planetary orbital parameters that should be returned to if the planets start moving too much
current_sma = np.array([0, 0, 0, 0]) | units.AU
correct_sma = np.array([5.4, 7.1, 10.5, 13]) | units.AU
inclinations = np.array([0, 0, 0, 0]) | units.deg
system = new_solar_system()
system = system[system.mass > 10**-5 | units.MSun] # Takes gas giants and Sun only
system.move_to_center()
for k in range(4):
orbital_elements = get_orbital_elements_from_binary(system[0]+ system[k+1], G=constants.G)
inclinations[k] = orbital_elements[5]
#------------------------------------------------------------------------------------------------------------
dead_comets = [] #Here all 'dead' comets are stored
#Below the evolving starts
for i in tqdm(range(len(times))):
gravity_bridge.evolve_model(times[i])
channel.copy()
#---------------------------------------------------------------------------------------------------------------
#Here we check if the planetary orbits are still 'correct' and act for three degrees of incorrectness.
for j in range(4):
current_sma[j] = sma_determinator(gravity_code.particles[0], gravity_code.particles[j+1])
for l in range(4):
if abs(current_sma[l]/correct_sma[l]) > 1.25 or abs(current_sma[l]/correct_sma[l]) < 0.75: #The orbits are too much perturbed, so we end the simulation
return
elif abs(current_sma[l]/correct_sma[l]) > 1.05 or abs(current_sma[l]/correct_sma[l]) < 0.95: #The orbits are slightly perturbed, so we redefinie them
print("Here", complete_post_tack_system[l+1].name, "was redefined")
binary = Particles(0)
binary.add_particle(gravity_code.particles[0])
binary.add_particle(gravity_code.particles[l+1])
orbital_params = get_orbital_elements_from_binary(binary, G = constants.G)
true_anomaly, ascending_node, pericenter = orbital_params[4].in_(units.deg), orbital_params[6].in_(units.deg), orbital_params[7].in_(units.deg)
sun_and_plan = new_binary_from_orbital_elements(1 | units.MSun, orbital_params[1], #We keep the current angles, but change the a, e and i back
correct_sma[l], 0, true_anomaly, inclinations[l], ascending_node, pericenter, G=constants.G)
gravity_code.particles[l+1].position = (sun_and_plan[1].x+gravity_code.particles[0].x, sun_and_plan[1].y+gravity_code.particles[0].y, sun_and_plan[1].z+gravity_code.particles[0].z)
gravity_code.particles[l+1].velocity = (sun_and_plan[1].vx+gravity_code.particles[0].vx, sun_and_plan[1].vy+gravity_code.particles[0].vy, sun_and_plan[1].vz+gravity_code.particles[0].vz)
else: #The orbits do not need changing
pass
#----------------------------------------------------------------------------------------------------------------------
#Once we checked for the orbital correctness, we can save data
if i%4000 == 0:
write_set_to_file(gravity_code.particles, directory + 'MWG_run' + str(run_number) +'_time=' + str(np.log10(times[i].value_in(units.yr)))[0:5] + '.hdf5', format='hdf5', overwrite_file = True)
#--------------------------------------------------------------------------------------------------------------------
#Here we look for 'escaped' and 'out of bounds' comets
out_of_bounds, escaped_comets = [], []
for i in range(len(gravity_code.particles)):
if (gravity_code.particles[i].position-gravity_code.particles[0].position).length() > 500 | units.AU:
escaped_comets.append(gravity_code.particles[i])
if (gravity_code.particles[i].position-gravity_code.particles[0].position).length() > 250000 | units.AU:
out_of_bounds.append(gravity_code.particles[i])
dead_comets.append(gravity_code.particles[i])
for particle in out_of_bounds: #Out of bounds comets are removed completely
complete_post_tack_system.remove_particle(particle)
complete_post_tack_system.synchronize_to(gravity_code.particles)
if i%100 == 0:
print("The amount of currently escaped comets is ", len(escaped_comets))
print("The amount of dead comets is ", len(dead_comets))
for m in range(4):
print(complete_post_tack_system[m+1].name, " is at ", (gravity_code.particles[m+1].position-gravity_code.particles[0].position).length().in_(units.AU))
gravity_code.stop()
write_set_to_file(gravity_code.orbiters, directory + 'MWG_run' + str(run_number) +'_final.hdf5', format='hdf5', overwrite_file = True)
return complete_post_tack