Beispiel #1
0
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
Beispiel #3
0
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
Beispiel #4
0
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
Beispiel #5
0
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
Beispiel #6
0
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