def simulation(par):
    saturn_a, saturn_e = par
    rebound.reset()
    rebound.integrator = "whfast-nocor"
    rebound.min_dt = 5.
    rebound.dt = 1.

    # These parameters are only approximately those of Jupiter and Saturn.
    sun = rebound.Particle(m=1.)
    rebound.add(sun)
    jupiter = rebound.add(primary=sun,
                          m=0.000954,
                          a=5.204,
                          anom=0.600,
                          omega=0.257,
                          e=0.048)
    saturn = rebound.add(primary=sun,
                         m=0.000285,
                         a=saturn_a,
                         anom=0.871,
                         omega=1.616,
                         e=saturn_e)

    rebound.move_to_com()
    rebound.init_megno(1e-16)
    rebound.integrate(1e3 * 2. * np.pi)

    return [
        rebound.calculate_megno(),
        1. / (rebound.calculate_lyapunov() * 2. * np.pi)
    ]  # returns MEGNO and Lypunov timescale in years
def simulation(par):
    saturn_a, saturn_e = par
    rebound.reset()
    rebound.integrator = "whfast-nocor"
    rebound.dt = 5.
    
    # These parameters are only approximately those of Jupiter and Saturn.
    rebound.add(m=1.)
    rebound.add(m=0.000954, a=5.204, anom=0.600, omega=0.257, e=0.048)
    rebound.add(m=0.000285, a=saturn_a, anom=0.871, omega=1.616, e=saturn_e)

    rebound.move_to_com()
    rebound.init_megno(1e-16)
    rebound.integrate(5e2*2.*np.pi) # integrator for 500 years

    return [rebound.calculate_megno(),1./(rebound.calculat_lyapunov()*2.*np.pi)] # returns MEGNO and Lypunov timescale in years
Esempio n. 3
0
 def energy():
     if integrator=="wh":
         rebound.move_to_com()
     particles = rebound.particles
     E_kin = 0.
     E_pot = 0.
     for i in xrange(N):
         E_kin += 0.5*particles[i].m*(particles[i].vx*particles[i].vx + particles[i].vy*particles[i].vy + particles[i].vz*particles[i].vz)
         for j in xrange(i+1,N):
             dx = particles[i].x-particles[j].x
             dy = particles[i].y-particles[j].y
             dz = particles[i].z-particles[j].z
             r2 = dx*dx + dy*dy + dz*dz
             E_pot -= G*particles[i].m*particles[j].m/np.sqrt(r2)
     if integrator=="wh":
         move_to_heliocentric()
     return E_kin+E_pot
Esempio n. 4
0
def simulation(integrator):
    print("Running "+integrator)
    with open(integrator+".txt","w") as f:
        rebound.reset()
        rebound.integrator = integrator
        rebound.dt = 0.2
            
        rebound.add(m=1.)
        rebound.add(m=0.01, a=1,e=0.1)
        rebound.add(m=0.01, a=2.)

        rebound.move_to_com()
        rebound.init_megno(1e-10)
        particles = rebound.particles
        times = np.logspace(2,5,num=1000)
        for t in times:
            rebound.integrate(t,0)
            print("%e %e %e %e %e %e %e %e\n" %(rebound.t, rebound.calculate_megno(), particles[0].x, particles[1].x, particles[2].x, particles[3].x, particles[4].x, particles[5].x),file=f)
def simulation(par):
    saturn_a, saturn_e = par
    rebound.reset()
    rebound.integrator = "whfast-nocor"
    rebound.min_dt = 5.
    rebound.dt = 1.
    
    # These parameters are only approximately those of Jupiter and Saturn.
    sun     = rebound.Particle(m=1.)
    rebound.add(sun)
    jupiter = rebound.add(primary=sun,m=0.000954, a=5.204, anom=0.600, omega=0.257, e=0.048)
    saturn  = rebound.add(primary=sun,m=0.000285, a=saturn_a, anom=0.871, omega=1.616, e=saturn_e)

    rebound.move_to_com()
    rebound.init_megno(1e-16)
    rebound.integrate(1e3*2.*np.pi)

    return [rebound.calculate_megno(),1./(rebound.calculate_lyapunov()*2.*np.pi)] # returns MEGNO and Lypunov timescale in years
Esempio n. 6
0
def simulation(par):
    saturn_a, saturn_e = par
    rebound.reset()
    rebound.integrator = "whfast-nocor"
    rebound.dt = 5.

    # These parameters are only approximately those of Jupiter and Saturn.
    rebound.add(m=1.)
    rebound.add(m=0.000954, a=5.204, anom=0.600, omega=0.257, e=0.048)
    rebound.add(m=0.000285, a=saturn_a, anom=0.871, omega=1.616, e=saturn_e)

    rebound.move_to_com()
    rebound.init_megno(1e-16)
    rebound.integrate(5e2 * 2. * np.pi)  # integrator for 500 years

    return [
        rebound.calculate_megno(),
        1. / (rebound.calculat_lyapunov() * 2. * np.pi)
    ]  # returns MEGNO and Lypunov timescale in years
 def energy():
     if integrator == "wh":
         rebound.move_to_com()
     particles = rebound.particles
     E_kin = 0.
     E_pot = 0.
     for i in xrange(N):
         E_kin += 0.5 * particles[i].m * (
             particles[i].vx * particles[i].vx + particles[i].vy *
             particles[i].vy + particles[i].vz * particles[i].vz)
         for j in xrange(i + 1, N):
             dx = particles[i].x - particles[j].x
             dy = particles[i].y - particles[j].y
             dz = particles[i].z - particles[j].z
             r2 = dx * dx + dy * dy + dz * dz
             E_pot -= G * particles[i].m * particles[j].m / np.sqrt(r2)
     if integrator == "wh":
         move_to_heliocentric()
     return E_kin + E_pot
Esempio n. 8
0
def simulation(integrator):
    print("Running " + integrator)
    with open(integrator + ".txt", "w") as f:
        rebound.reset()
        rebound.integrator = integrator
        rebound.dt = 0.2

        rebound.add(m=1.)
        rebound.add(m=0.01, a=1, e=0.1)
        rebound.add(m=0.01, a=2.)

        rebound.move_to_com()
        rebound.init_megno(1e-10)
        particles = rebound.particles
        times = np.logspace(2, 5, num=1000)
        for t in times:
            rebound.integrate(t, 0)
            print("%e %e %e %e %e %e %e %e\n" %
                  (rebound.t, rebound.calculate_megno(), particles[0].x,
                   particles[1].x, particles[2].x, particles[3].x,
                   particles[4].x, particles[5].x),
                  file=f)
Esempio n. 9
0
import rebound
import os.path

filename = "cache.bin"

solar_system_objects = [
    "Sun", "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus",
    "Neptune", "C/2014 Q2"
]
if os.path.isfile(filename):
    rebound.load(filename)
else:
    # Get data from NASA Horizons
    rebound.add(solar_system_objects)
    rebound.move_to_com()
    # Let's save it for next time
    # Note: rebound.save() only saves the particle data, not the integrator settings, etc.
    rebound.save("cache.bin")

rebound.integrator = "whfast"
rebound.set_dt = 0.01
rebound.status()

import numpy as np
Nout = 1000
times = np.linspace(0, 16. * np.pi, Nout)  # 8 years
x = np.zeros((rebound.N, Nout))
y = np.zeros((rebound.N, Nout))

ps = rebound.particles
for ti, t in enumerate(times):
Esempio n. 10
0
# Import the rebound module
import rebound

# Add particles
# We work in units where G=1.  
rebound.add(m=1. )                  # Test particle
rebound.add(m=1e-3,x=1.,vy=1. )     # Planet

# Move particles so that the center of mass is (and stays) at the origin  
rebound.move_to_com()

# You can provide a function, written in python to REBOUND.
# This function gets called every time the forces are evaluated.
# Simple add any any additional (non-gravitational) forces to the 
# particle accelerations. Here, we add a simple drag force. This 
# will make the planet spiral into the star.
ps = rebound.particles
def dragforce():
    dragcoefficient = 1e-2
    for p in ps:
        p.ax += -dragcoefficient * p.vx
        p.ay += -dragcoefficient * p.vy
        p.az += -dragcoefficient * p.vz

# Tell rebound which function to call
rebound.additional_forces = dragforce

# Integrate until t=100 (roughly 16 orbits at 1 AU) 
rebound.integrate(100.)

# Output something at the end (the planet will be at ~0.1 AU)
def simulation(par):
    import rebound
    integrator, dt, run = par
    rebound.reset()
    k = 0.01720209895
    G = k * k
    rebound.G = G
    rebound.dt = dt
    rebound.integrator = integrator
    rebound.force_is_velocitydependent = 0

    rebound.add(m=1.00000597682,
                x=-4.06428567034226e-3,
                y=-6.08813756435987e-3,
                z=-1.66162304225834e-6,
                vx=+6.69048890636161e-6,
                vy=-6.33922479583593e-6,
                vz=-3.13202145590767e-9)  # Sun
    rebound.add(m=1. / 1407.355,
                x=+3.40546614227466e+0,
                y=+3.62978190075864e+0,
                z=+3.42386261766577e-2,
                vx=-5.59797969310664e-3,
                vy=+5.51815399480116e-3,
                vz=-2.66711392865591e-6)  # Jupiter
    rebound.add(m=1. / 3501.6,
                x=+6.60801554403466e+0,
                y=+6.38084674585064e+0,
                z=-1.36145963724542e-1,
                vx=-4.17354020307064e-3,
                vy=+3.99723751748116e-3,
                vz=+1.67206320571441e-5)  # Saturn
    rebound.add(m=1. / 22869.,
                x=+1.11636331405597e+1,
                y=+1.60373479057256e+1,
                z=+3.61783279369958e-1,
                vx=-3.25884806151064e-3,
                vy=+2.06438412905916e-3,
                vz=-2.17699042180559e-5)  # Uranus
    rebound.add(m=1. / 19314.,
                x=-3.01777243405203e+1,
                y=+1.91155314998064e+0,
                z=-1.53887595621042e-1,
                vx=-2.17471785045538e-4,
                vy=-3.11361111025884e-3,
                vz=+3.58344705491441e-5)  # Neptune
    N = rebound.N
    particles = rebound.particles
    np.random.seed(run)
    for i in xrange(N):
        particles[i].m *= 1. + 1e-3 * np.random.rand()
        particles[i].x *= 1. + 1e-3 * np.random.rand()
        particles[i].y *= 1. + 1e-3 * np.random.rand()
        particles[i].z *= 1. + 1e-3 * np.random.rand()
        particles[i].vx *= 1. + 1e-3 * np.random.rand()
        particles[i].vy *= 1. + 1e-3 * np.random.rand()
        particles[i].vz *= 1. + 1e-3 * np.random.rand()

    def move_to_heliocentric():
        particles[0].x = 0.
        particles[0].y = 0.
        particles[0].z = 0.
        particles[0].vx = 0.
        particles[0].vy = 0.
        particles[0].vz = 0.

    def energy():
        com_vx = 0.
        com_vy = 0.
        com_vz = 0.
        if integrator == "wh" or integrator == "mercury" or integrator[
                0:7] == "swifter":
            mtot = 0.
            for i in xrange(0, N):
                com_vx += particles[i].vx * particles[i].m
                com_vy += particles[i].vy * particles[i].m
                com_vz += particles[i].vz * particles[i].m
                mtot += particles[i].m
            com_vx /= mtot
            com_vy /= mtot
            com_vz /= mtot
        E_kin = 0.
        E_pot = 0.
        for i in xrange(N):
            dvx = particles[i].vx - com_vx
            dvy = particles[i].vy - com_vy
            dvz = particles[i].vz - com_vz
            E_kin += 0.5 * particles[i].m * (dvx * dvx + dvy * dvy + dvz * dvz)
            for j in xrange(i + 1, N):
                dx = particles[i].x - particles[j].x
                dy = particles[i].y - particles[j].y
                dz = particles[i].z - particles[j].z
                r2 = dx * dx + dy * dy + dz * dz
                E_pot -= G * particles[i].m * particles[j].m / np.sqrt(r2)
        return E_kin + E_pot

    if integrator == "wh" or integrator == "mercury" or integrator[
            0:7] == "swifter":
        move_to_heliocentric()
    else:
        rebound.move_to_com()
    ei = energy()

    runtime = 0.
    rebound.integrate(tmax, exactFinishTime=0)
    ef = energy()
    e = np.fabs((ei - ef) / ei) + 1.1e-16
    runtime += rebound.timing

    integrator, dt, run = par
    print integrator.ljust(13) + " %9.5fs" % (runtime) + "\t Error: %e" % (e)
    return [runtime, e]
Esempio n. 12
0
import rebound
import reboundxf
import numpy as np 

rebound.integrator = "ias15"
rebound.G = 4*np.pi**2
tmax = 1.e4 # years

rebound.add(m=1.)
rebound.add(m=1e-6,a=1.,e=0.5)
#rebound.add(m=1e-6,a=2.,e=0.5)
rebound.move_to_com() # Moves to the center of momentum frame

rebound.additional_forces = reboundxf.forces()
reboundxf.set_e_damping([0.,tmax/10.])#,tmax])
reboundxf.set_migration([0.,0.])#,tmax])

Nout = 1000
e1,e2,a1,a2 = np.zeros(Nout), np.zeros(Nout), np.zeros(Nout), np.zeros(Nout)
times = np.linspace(0.,tmax,Nout)
for i,time in enumerate(times):
    rebound.integrate(time)
    orbits = rebound.calculate_orbits()
    e1[i] = orbits[0].e
    #e2[i] = orbits[1].e
    a1[i] = orbits[0].a
    #a2[i] = orbits[1].a

import matplotlib.pyplot as plt
fig = plt.figure(figsize=(15,5))
ax = plt.subplot(111)
Esempio n. 13
0
def simulation(par):
    import rebound
    integrator, dt, run = par
    rebound.reset()
    k = 0.01720209895    
    G = k*k
    rebound.G = G     
    rebound.dt = dt
    if integrator == "whfast-nocor":
        integrator = "whfast"
    else:
        rebound.integrator_whfast_corrector = 11
    rebound.integrator = integrator
    rebound.force_is_velocitydependent = 0

    rebound.add(m=1.00000597682, x=-4.06428567034226e-3, y=-6.08813756435987e-3, z=-1.66162304225834e-6, vx=+6.69048890636161e-6, vy=-6.33922479583593e-6, vz=-3.13202145590767e-9)   # Sun
    rebound.add(m=1./1407.355,   x=+3.40546614227466e+0, y=+3.62978190075864e+0, z=+3.42386261766577e-2, vx=-5.59797969310664e-3, vy=+5.51815399480116e-3, vz=-2.66711392865591e-6)   # Jupiter
    rebound.add(m=1./3501.6,     x=+6.60801554403466e+0, y=+6.38084674585064e+0, z=-1.36145963724542e-1, vx=-4.17354020307064e-3, vy=+3.99723751748116e-3, vz=+1.67206320571441e-5)   # Saturn
    rebound.add(m=1./22869.,     x=+1.11636331405597e+1, y=+1.60373479057256e+1, z=+3.61783279369958e-1, vx=-3.25884806151064e-3, vy=+2.06438412905916e-3, vz=-2.17699042180559e-5)   # Uranus
    rebound.add(m=1./19314.,     x=-3.01777243405203e+1, y=+1.91155314998064e+0, z=-1.53887595621042e-1, vx=-2.17471785045538e-4, vy=-3.11361111025884e-3, vz=+3.58344705491441e-5)   # Neptune
    N = rebound.N
    particles = rebound.particles
    np.random.seed(run)
    for i in xrange(N):
        particles[i].m *= 1.+1e-3*np.random.rand()
        particles[i].x *= 1.+1e-3*np.random.rand()
        particles[i].y *= 1.+1e-3*np.random.rand()
        particles[i].z *= 1.+1e-3*np.random.rand()
        particles[i].vx *= 1.+1e-3*np.random.rand()
        particles[i].vy *= 1.+1e-3*np.random.rand()
        particles[i].vz *= 1.+1e-3*np.random.rand()

    def move_to_heliocentric():
        particles[0].x  = 0.
        particles[0].y  = 0. 
        particles[0].z  = 0. 
        particles[0].vx = 0. 
        particles[0].vy = 0. 
        particles[0].vz = 0. 


    def energy():
        com_vx = 0.
        com_vy = 0.
        com_vz = 0.
        if integrator=="wh" or integrator=="mercury" or integrator[0:7]=="swifter":
            mtot = 0.
            for i in xrange(0,N):
                com_vx += particles[i].vx*particles[i].m 
                com_vy += particles[i].vy*particles[i].m 
                com_vz += particles[i].vz*particles[i].m 
                mtot += particles[i].m
            com_vx /= mtot
            com_vy /= mtot
            com_vz /= mtot
        E_kin = 0.
        E_pot = 0.
        for i in xrange(N):
            dvx = particles[i].vx - com_vx
            dvy = particles[i].vy - com_vy
            dvz = particles[i].vz - com_vz
            E_kin += 0.5*particles[i].m*(dvx*dvx + dvy*dvy + dvz*dvz)
            for j in xrange(i+1,N):
                dx = particles[i].x-particles[j].x
                dy = particles[i].y-particles[j].y
                dz = particles[i].z-particles[j].z
                r2 = dx*dx + dy*dy + dz*dz
                E_pot -= G*particles[i].m*particles[j].m/np.sqrt(r2)
        return E_kin+E_pot

    if integrator=="wh" or integrator=="mercury" or integrator[0:7]=="swifter":
        move_to_heliocentric()
    else:
        rebound.move_to_com()
    ei = energy()


    runtime = 0.
    rebound.integrate(tmax,exact_finish_time=0)
    ef = energy()
    e = np.fabs((ei-ef)/ei)+1.1e-16
    runtime += rebound.timing
    
    integrator, dt, run = par
    print integrator.ljust(13) + " %9.5fs"%(runtime) + "\t Error: %e"  %( e)
    return [runtime, e]
Esempio n. 14
0
def simulation(par):
    integrator, mass = par
    rebound.reset()
    mass = pow(10.,mass)
    k = 0.01720209895    
    G = k*k
    rebound.G = G     
    rebound.dt = 0.
    rebound.integrator = integrator

    rebound.add(m=1.00000597682, x=-4.06428567034226e-3, y=-6.08813756435987e-3, z=-1.66162304225834e-6, vx=+6.69048890636161e-6, vy=-6.33922479583593e-6, vz=-3.13202145590767e-9)   # Sun
    rebound.add(m=mass,   x=+3.40546614227466e+0, y=+3.62978190075864e+0, z=+3.42386261766577e-2, vx=-5.59797969310664e-3, vy=+5.51815399480116e-3, vz=-2.66711392865591e-6)   # Jupiter
    rebound.add(m=mass,     x=+6.60801554403466e+0, y=+6.38084674585064e+0, z=-1.36145963724542e-1, vx=-4.17354020307064e-3, vy=+3.99723751748116e-3, vz=+1.67206320571441e-5)   # Saturn
    rebound.add(m=mass,     x=+1.11636331405597e+1, y=+1.60373479057256e+1, z=+3.61783279369958e-1, vx=-3.25884806151064e-3, vy=+2.06438412905916e-3, vz=-2.17699042180559e-5)   # Uranus
    rebound.add(m=mass,     x=-3.01777243405203e+1, y=+1.91155314998064e+0, z=-1.53887595621042e-1, vx=-2.17471785045538e-4, vy=-3.11361111025884e-3, vz=+3.58344705491441e-5)   # Neptune
    N = rebound.N

    def move_to_heliocentric():
        particles = rebound.particles
        
        for i in xrange(1,N):
            particles[i].x -= particles[0].x
            particles[i].y -= particles[0].y
            particles[i].z -= particles[0].z
            particles[i].vx -= particles[0].vx
            particles[i].vy -= particles[0].vy
            particles[i].vz -= particles[0].vz
        particles[0].x  = 0.
        particles[0].y  = 0. 
        particles[0].z  = 0. 
        particles[0].vx = 0. 
        particles[0].vy = 0. 
        particles[0].vz = 0. 


    def energy():
        if integrator=="wh":
            rebound.move_to_com()
        particles = rebound.particles
        E_kin = 0.
        E_pot = 0.
        for i in xrange(N):
            E_kin += 0.5*particles[i].m*(particles[i].vx*particles[i].vx + particles[i].vy*particles[i].vy + particles[i].vz*particles[i].vz)
            for j in xrange(i+1,N):
                dx = particles[i].x-particles[j].x
                dy = particles[i].y-particles[j].y
                dz = particles[i].z-particles[j].z
                r2 = dx*dx + dy*dy + dz*dz
                E_pot -= G*particles[i].m*particles[j].m/np.sqrt(r2)
        if integrator=="wh":
            move_to_heliocentric()
        return E_kin+E_pot

    rebound.move_to_com()
    ei = energy()

    es = 1e-20

    for s in xrange(1000):
        rebound.step()
        ef = energy()
        e = np.fabs((ei-ef)/ei)
        es = max(es,e)

    return es
def simulation(par):
    integrator, mass = par
    rebound.reset()
    mass = pow(10., mass)
    k = 0.01720209895
    G = k * k
    rebound.G = G
    rebound.dt = 0.
    rebound.integrator = integrator

    rebound.add(m=1.00000597682,
                x=-4.06428567034226e-3,
                y=-6.08813756435987e-3,
                z=-1.66162304225834e-6,
                vx=+6.69048890636161e-6,
                vy=-6.33922479583593e-6,
                vz=-3.13202145590767e-9)  # Sun
    rebound.add(m=mass,
                x=+3.40546614227466e+0,
                y=+3.62978190075864e+0,
                z=+3.42386261766577e-2,
                vx=-5.59797969310664e-3,
                vy=+5.51815399480116e-3,
                vz=-2.66711392865591e-6)  # Jupiter
    rebound.add(m=mass,
                x=+6.60801554403466e+0,
                y=+6.38084674585064e+0,
                z=-1.36145963724542e-1,
                vx=-4.17354020307064e-3,
                vy=+3.99723751748116e-3,
                vz=+1.67206320571441e-5)  # Saturn
    rebound.add(m=mass,
                x=+1.11636331405597e+1,
                y=+1.60373479057256e+1,
                z=+3.61783279369958e-1,
                vx=-3.25884806151064e-3,
                vy=+2.06438412905916e-3,
                vz=-2.17699042180559e-5)  # Uranus
    rebound.add(m=mass,
                x=-3.01777243405203e+1,
                y=+1.91155314998064e+0,
                z=-1.53887595621042e-1,
                vx=-2.17471785045538e-4,
                vy=-3.11361111025884e-3,
                vz=+3.58344705491441e-5)  # Neptune
    N = rebound.N

    def move_to_heliocentric():
        particles = rebound.particles

        for i in xrange(1, N):
            particles[i].x -= particles[0].x
            particles[i].y -= particles[0].y
            particles[i].z -= particles[0].z
            particles[i].vx -= particles[0].vx
            particles[i].vy -= particles[0].vy
            particles[i].vz -= particles[0].vz
        particles[0].x = 0.
        particles[0].y = 0.
        particles[0].z = 0.
        particles[0].vx = 0.
        particles[0].vy = 0.
        particles[0].vz = 0.

    def energy():
        if integrator == "wh":
            rebound.move_to_com()
        particles = rebound.particles
        E_kin = 0.
        E_pot = 0.
        for i in xrange(N):
            E_kin += 0.5 * particles[i].m * (
                particles[i].vx * particles[i].vx + particles[i].vy *
                particles[i].vy + particles[i].vz * particles[i].vz)
            for j in xrange(i + 1, N):
                dx = particles[i].x - particles[j].x
                dy = particles[i].y - particles[j].y
                dz = particles[i].z - particles[j].z
                r2 = dx * dx + dy * dy + dz * dz
                E_pot -= G * particles[i].m * particles[j].m / np.sqrt(r2)
        if integrator == "wh":
            move_to_heliocentric()
        return E_kin + E_pot

    rebound.move_to_com()
    ei = energy()

    es = 1e-20

    for s in xrange(1000):
        rebound.step()
        ef = energy()
        e = np.fabs((ei - ef) / ei)
        es = max(es, e)

    return es