def main():
filename = "SunAndEarthAndMoon.hdf"
ss = new_system_of_sun_and_earth()
star = ss[0]
planet = ss[1]
moon = ss[2]
converter = nbody_system.nbody_to_si(star.mass, planet.position.length())
star_gravity = ph4(converter)
star_gravity.particles.add_particle(star)
planet_gravity = ph4(converter)
planet_gravity.particles.add_particle(planet)
moon_gravity = ph4(converter)
moon_gravity.particles.add_particle(moon)
channel_from_star_to_framework = star_gravity.particles.new_channel_to(ss)
channel_from_planet_to_framework = planet_gravity.particles.new_channel_to(
ss)
channel_from_moon_to_framework = moon_gravity.particles.new_channel_to(ss)
write_set_to_file(ss, filename, 'hdf5')
sp_gravity = bridge.Bridge()
sp_gravity.add_system(moon_gravity, (planet_gravity, ))
sp_gravity.add_system(planet_gravity, (moon_gravity, ))
gravity = bridge.Bridge()
gravity.add_system(sp_gravity, (star_gravity, ))
gravity.add_system(star_gravity, (sp_gravity, ))
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot_prev = Etot_init
sp_gravity.timestep = 1 | units.day
gravity.timestep = 10 | units.day
time = zero
dt = 3 | units.day
t_end = 1 | units.yr
while time < t_end:
time += dt
gravity.evolve_model(time)
Etot_prev_se = gravity.kinetic_energy + gravity.potential_energy
channel_from_star_to_framework.copy()
channel_from_planet_to_framework.copy()
channel_from_moon_to_framework.copy()
write_set_to_file(ss, filename, 'hdf5')
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
print "T=", time,
print "E= ", Etot, "Q= ", Ekin / Epot,
print "dE=", (Etot_init - Etot) / Etot, "ddE=", (Etot_prev -
Etot) / Etot
Etot_prev = Etot
gravity.stop()
def test3(self):
print "Bridge potential energy with radius as softening length"
convert = nbody_system.nbody_to_si(1.e5 | units.MSun,
1.0 | units.parsec)
epsilon = 0.1 | units.parsec
test_class = ExampleGravityCodeInterface
numpy.random.seed(12345)
stars = new_plummer_model(100, convert_nbody=convert)
stars.radius = epsilon
cluster = test_class()
cluster.parameters.epsilon_squared = epsilon**2
cluster.particles.add_particles(stars)
first_half = stars.select_array(lambda x: (x > 0 | units.m), ['x'])
second_half = stars - first_half
cluster1 = system_from_particles(test_class, dict(), first_half,
epsilon)
cluster2 = system_from_particles(test_class, dict(), second_half,
epsilon)
bridgesys = bridge.Bridge()
bridgesys.add_system(cluster1, (cluster2, ), radius_is_eps=True)
bridgesys.add_system(cluster2, (cluster1, ))
self.assertAlmostRelativeEqual(cluster.potential_energy,
bridgesys.potential_energy)
self.assertAlmostRelativeEqual(cluster.kinetic_energy,
bridgesys.kinetic_energy)
def gravity_code_setup(code_name, orbiter_name, Mgalaxy, Rgalaxy, galaxy_code,
sepBinary, rvals, phivals, zvals, vrvals, vphivals,
vzvals, masses, radii, Norbiters):
'''
will need to ask SPZ if he meant for field, orbiter to be separate in non
Nemesis gravity solvers?
'''
gravity = bridge.Bridge(use_threading=False)
converter_parent = nbody_system.nbody_to_si(Mgalaxy, Rgalaxy)
converter_sub = nbody_system.nbody_to_si(
np.median(masses) | units.MSun,
np.median(radii) | units.parsec) #masses list is in solar mass units
channel = stars.new_channel_to(orbiter_code.particles)
channel.copy_attributes(['mass', 'x', 'y', 'z', 'vx', 'vy', 'vz'])
stellar = SeBa()
stellar.particles.add_particles(cluster_code.particles)
#bridges each cluster with the bulge, not the other way around though
gravity.add_system(cluster_code, other_things)
return gravity.particles, gravity, orbiter_bodies_list, cluster_colors, stellar
def integrate_amuse(orb,pot,tmax,vo,ro):
"""Integrate a snapshot in infile until tmax in Gyr, save to outfile"""
time=0.0 | tmax.unit
dt = tmax/10001.
orbit = Particles(1)
orbit.mass= 1. | units.MSun
orbit.radius = 1. |units.RSun
orbit.position=[orb.x(),orb.y(),orb.z()] | units.kpc
orbit.velocity=[orb.vx(),orb.vy(),orb.vz()] | units.kms
galaxy_code = to_amuse(pot,ro=ro,vo=vo)
orbit_gravity=drift_without_gravity(orbit)
orbit_gravity.particles.add_particles(orbit)
channel_from_gravity_to_orbit= orbit_gravity.particles.new_channel_to(orbit)
gravity = bridge.Bridge(use_threading=False)
gravity.add_system(orbit_gravity, (galaxy_code,))
gravity.add_system(galaxy_code,)
gravity.timestep = dt
while time <= tmax:
time += dt
gravity.evolve_model(time)
channel_from_gravity_to_orbit.copy()
gravity.stop()
return orbit.x[0].value_in(units.kpc),orbit.y[0].value_in(units.kpc),orbit.z[0].value_in(units.kpc),orbit.vx[0].value_in(units.kms),orbit.vy[0].value_in(units.kms),orbit.vz[0].value_in(units.kms)
def main():
filename = "SunAndEarthAndMoon_TBB.h5"
ss = new_system_of_sun_and_earth()
star = ss[0]
planet = ss[1]
moon = ss[2]
print moon
converter=nbody_system.nbody_to_si(star.mass, 1|units.AU)
star_gravity = ph4(converter)
star_gravity.particles.add_particle(star)
planet_gravity = ph4(converter)
planet_gravity.particles.add_particle(planet)
moon_gravity = ph4(converter)
moon_gravity.particles.add_particle(moon)
channel_from_star_to_framework = star_gravity.particles.new_channel_to(ss)
channel_from_planet_to_framework = planet_gravity.particles.new_channel_to(ss)
channel_from_moon_to_framework = moon_gravity.particles.new_channel_to(ss)
write_set_to_file(ss.savepoint(0.0|units.Myr), filename, 'hdf5', append_to_file=False, version='2')
gravity = bridge.Bridge(use_threading=False, method=SPLIT_4TH_S_M4)
####gravity = bridge.Bridge(use_threading=False, method=SPLIT_6TH_SS_M13)
gravity.add_system(star_gravity, (planet_gravity,moon_gravity) )
gravity.add_system(planet_gravity, (star_gravity,moon_gravity) )
gravity.add_system(moon_gravity, (star_gravity,planet_gravity) )
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot_prev = Etot_init
DDE_max = 0
gravity.timestep = 1|units.day
time = zero
dt = 30|units.day
t_end = 100 | units.yr
while time < t_end:
time += dt
gravity.evolve_model(time)
Etot_prev_se = gravity.kinetic_energy + gravity.potential_energy
channel_from_star_to_framework.copy()
channel_from_planet_to_framework.copy()
channel_from_moon_to_framework.copy()
write_set_to_file(ss.savepoint(time), filename, 'hdf5', version='2')
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
DDE = (Etot_prev-Etot)/Etot
DDE_max = max(abs(DDE_max), abs(DDE))
print "T=", time,
print "E= ", Etot, "Q= ", Ekin/Epot,
print "dE=", (Etot_init-Etot)/Etot, "ddE=", DDE, "dde_min=", DDE_max
Etot_prev = Etot
gravity.stop()
def main(Ncl, rcl, W0, Rgal, vgal, t_end, n_steps):
masses = new_salpeter_mass_distribution(Ncl, 1 | units.MSun,
100 | units.MSun)
converter = nbody_system.nbody_to_si(masses.sum(), rcl)
bodies = new_king_model(Ncl, W0, convert_nbody=converter)
bodies.mass = masses
bodies.scale_to_standard(convert_nbody=converter)
stellar = SeBa()
stellar.particles.add_particles(bodies)
channel_from_stellar_to_framework = stellar.particles.new_channel_to(
bodies)
channel_from_stellar_to_framework.copy()
bodies.x += Rgal
bodies.vy += vgal
CDG = BHTree(converter)
CDG.particles.add_particles(bodies)
channel_from_gravity_to_framework = CDG.particles.new_channel_to(bodies)
gravity = bridge.Bridge()
gravity.add_system(CDG, (MilkyWay_galaxy(), ))
dt = t_end / float(n_steps)
gravity.timestep = dt
filename = "nbody.hdf5"
write_set_to_file(bodies.savepoint(0.0 | t_end.unit),
filename,
"hdf5",
append_to_file=False)
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot_prev = Etot_init
time = zero
dt = t_end / float(n_steps)
while time < t_end:
time += dt
stellar.evolve_model(time)
channel_from_stellar_to_framework.copy()
gravity.evolve_model(time)
channel_from_gravity_to_framework.copy()
write_set_to_file(bodies.savepoint(time), filename, "hdf5")
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
print "T=", time, "M=", bodies.mass.sum(),
print "E= ", Etot, "Q= ", Ekin / Epot,
print "dE=", (Etot_init - Etot) / Etot, "ddE=", (Etot_prev -
Etot) / Etot
Etot_prev = Etot
gravity.stop()
def create_bridge(self):
bridge_code1 = bridge.GravityCodeInField(self.gas_code,
self.star_to_gas_codes)
bridge_code2 = bridge.GravityCodeInField(self.star_code,
self.gas_to_star_codes)
self.bridge_system = bridge.Bridge(timestep=self.interaction_timestep,
use_threading=False)
self.bridge_system.add_code(bridge_code2)
self.bridge_system.add_code(bridge_code1)
def evolve_cluster_in_galaxy(N, Mcluster, Rcluster, Rinit, Vinit, galaxy_code,
dt, dtout, tend, epsilon):
#Setup cluster
stars, converter = setup_cluster(N, Mcluster, Rcluster, Rinit, Vinit)
stars.scale_to_standard(convert_nbody=converter,
smoothing_length_squared=epsilon**2)
cluster_code = BHTree(
converter, number_of_workers=1
) #Change number of workers depending on CPUS available
cluster_code.parameters.epsilon_squared = epsilon**2
cluster_code.parameters.opening_angle = 0.6
cluster_code.parameters.timestep = dt
cluster_code.particles.add_particles(stars)
#Setup channels between stars particle dataset and the cluster code
channel_from_stars_to_cluster_code = stars.new_channel_to(
cluster_code.particles,
attributes=["mass", "x", "y", "z", "vx", "vy", "vz"])
channel_from_cluster_code_to_stars = cluster_code.particles.new_channel_to(
stars, attributes=["mass", "x", "y", "z", "vx", "vy", "vz"])
#Setup gravity bridge
gravity = bridge.Bridge(use_threading=False)
#stars in cluster_code depend on gravity from galaxy_code
gravity.add_system(cluster_code, (galaxy_code, ))
#galaxy_code still needs to be added to system so it evolves with time
gravity.add_system(galaxy_code, )
#Set how often to update external potential
gravity.timestep = cluster_code.parameters.timestep / 2.
time = 0.0 | tend.unit
while time < tend:
print(time.value_in(units.Myr), tend.value_in(units.Myr))
gravity.evolve_model(time + dt)
#You need to copy stars from cluster_code to output or analyse:
#channel_from_cluster_code_to_stars.copy()
#Output/Analyse
#If you edited the stars particle set, lets say to remove stars from the array because they have
#been kicked far from the cluster, you need to copy the array back to cluster_code:
#channel_from_stars_to_cluster_code.copy()
time = gravity.model_time
#Copy back to stars for final dataset
channel_from_cluster_code_to_stars.copy()
gravity.stop()
return stars
def gravity_hydro_bridge(gravity, hydro, t_end, dt):
model_time = 0 | units.yr
filename = "gravhydro.hdf5"
#write_set_to_file(stars.savepoint(model_time), filename, 'amuse')
#write_set_to_file(gas, filename, 'amuse')
gravhydro = bridge.Bridge(use_threading=False)
gravhydro.add_system(gravity, (hydro, ))
gravhydro.add_system(hydro, (gravity, ))
gravhydro.timestep = 2 * hydro.get_timestep()
a_Jup = list()
e_Jup = list()
disk_size = list()
# start evolotuion
print 'Start evolving...'
times = quantities.arange(0. | units.yr, t_end + dt, dt)
while model_time < t_end:
stars = gravity.local_particles
orbit = orbital_elements_from_binary(stars, G=constants.G)
a = orbit[2].value_in(units.AU)
e = orbit[3]
if model_time.value_in(units.yr) % 50 == 0:
print "Time:", model_time.in_(units.yr), \
"ae=", a ,e
a_Jup.append(a)
e_Jup.append(e)
model_time += gravhydro.timestep
gravhydro.evolve_model(model_time)
gravity.copy_to_framework()
hydro.copy_to_framework()
sink = hydro.local_particles[0]
_ = hydro_sink_particles([sink], hydro.local_particles[1:])
Jupiter = gravity.local_particles[1]
Jupiter.mass += sink.mass
sink.position = Jupiter.position
sink.radius = a * (1 - e) * (
(1.0 | units.MJupiter).value_in(units.MSun) / 3.)**(1. /
3.) | units.au
gravity.copy_to_framework()
hydro.copy_to_framework()
write_set_to_file(stars.savepoint(model_time), filename, 'amuse')
write_set_to_file(ism, filename, 'amuse')
print "P=", model_time.in_(units.yr), gravity.particles.x.in_(units.au)
gravity.stop()
hydro.stop()
return a_Jup, e_Jup, times
def evolve_model(end_time, double_star, stars):
time = 0 | units.yr
dt = end_time/100.
converter = nbody_system.nbody_to_si(double_star.mass,
double_star.semimajor_axis)
gravity = Hermite(converter)
gravity.particles.add_particle(stars)
to_stars = gravity.particles.new_channel_to(stars)
# from_stars = stars.new_channel_to(gravity.particles)
massloss_code = CodeWithMassLoss(gravity, ())
gravml = bridge.Bridge(use_threading=False)
gravml.timestep = 0.5*dt
gravml.add_system(gravity,)
gravml.add_code(massloss_code)
a = [] | units.au
e = []
m = [] | units.MSun
t = [] | units.yr
while time < end_time:
time += dt
gravml.evolve_model(time)
to_stars.copy()
orbital_elements = orbital_elements_from_binary(stars,
G=constants.G)
a.append(orbital_elements[2])
e.append(orbital_elements[3])
m.append(stars.mass.sum())
t.append(time)
print("time=", time.in_(units.yr),
"a=", a[-1].in_(units.RSun),
"e=", e[-1],
"m=", stars.mass.in_(units.MSun))
gravity.stop()
from matplotlib import pyplot
fig, axis = pyplot.subplots(nrows=2, ncols=2, sharex=True)
axis[0][0].scatter(t.value_in(units.yr), a.value_in(units.RSun))
axis[0][0].set_ylabel("a [$R_\odot$]")
axis[0][1].scatter(t.value_in(units.yr), m.value_in(units.MSun))
axis[0][1].set_ylabel("M [$M_\odot$]")
axis[1][1].scatter(t.value_in(units.yr), e)
axis[1][1].set_ylabel("e")
axis[1][1].set_xlabel("time [yr]")
axis[1][0].set_xlabel("time [yr]")
pyplot.savefig("mloss_bridge.png")
pyplot.show()
def main():
filename = "SunAndEarth.hdf"
ss = new_solar_system()
star = ss[0]
planet = ss[3]
converter = nbody_system.nbody_to_si(star.mass, planet.position.length())
###BOOKLISTSTART###
star_gravity = ph4(converter)
star_gravity.particles.add_particle(star)
planet_gravity = ph4(converter)
planet_gravity.particles.add_particle(planet)
channel_from_star_to_framework = star_gravity.particles.new_channel_to(ss)
channel_from_planet_to_framework = planet_gravity.particles.new_channel_to(
ss)
gravity = bridge.Bridge(use_threading=False)
gravity.add_system(star_gravity, (planet_gravity, ))
gravity.add_system(planet_gravity, (star_gravity, ))
###BOOKLISTSTOP###
write_set_to_file(ss, filename, 'hdf5', append_to_file=Fale)
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot_prev = Etot_init
gravity.timestep = 1 | units.day
time = zero
dt = 10 | units.day
t_end = 100 | units.yr
while time < t_end:
time += dt
gravity.evolve_model(time)
Etot_prev_se = gravity.kinetic_energy + gravity.potential_energy
channel_from_star_to_framework.copy()
channel_from_planet_to_framework.copy()
write_set_to_file(ss, filename, 'hdf5')
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
print "T=", time,
print "E= ", Etot, "Q= ", Ekin / Epot,
print "dE=", (Etot_init - Etot) / Etot, "ddE=", (Etot_prev -
Etot) / Etot
Etot_prev = Etot
gravity.stop()
def create_bridge(self):
self.bridge_system = bridge.Bridge(
timestep=self.interaction_timestep_in_si,
use_threading=False
)
self.bridge_system.add_system(
self.gas_code,
self.star_to_gas_codes
)
self.bridge_system.add_system(
self.star_code,
self.gas_to_star_codes
)
def evolve_binary_in_common_envelope(stars, envelope, t_end):
R = stars.position.length()
converter = nbody_system.nbody_to_si(stars.mass.sum(), R)
gravity = ph4(converter)
gravity.particles.add_particles(stars)
channel_from_gravity = gravity.particles.new_channel_to(stars)
channel_from_to_gravity = stars.new_channel_to(gravity.particles)
n_steps = 10
dt = t_end / float(n_steps)
hydro = Fi(converter, redirection="none")
tdyn = numpy.sqrt((0.05 * R)**3 / (constants.G * stars.mass.sum()))
print "tdyn=", tdyn
hydro.parameters.timestep = tdyn
hydro.parameters.epsilon_squared = (1 | units.RSun)**2
hydro.gas_particles.add_particles(envelope)
hydro.parameters.periodic_box_size = 100 * R
channel_from_hydro = hydro.gas_particles.new_channel_to(envelope)
channel_from_to_hydro = envelope.new_channel_to(hydro.gas_particles)
model_time = 0 | units.Myr
filename = "XiTau_Hydro.amuse"
write_set_to_file(stars.savepoint(model_time),
filename,
'amuse',
append_to_file=False)
write_set_to_file(envelope, filename, 'amuse')
gravhydro = bridge.Bridge(use_threading=False)
gravhydro.add_system(gravity, (hydro, ))
gravhydro.add_system(hydro, (gravity, ))
gravhydro.timestep = min(dt, 10 * hydro.parameters.timestep)
while model_time < t_end:
model_time += dt
print "Time=", model_time.in_(units.day)
gravhydro.evolve_model(model_time)
channel_from_gravity.copy()
channel_from_hydro.copy()
write_set_to_file(stars.savepoint(model_time), filename, 'amuse')
write_set_to_file(envelope, filename, 'amuse')
gravity.stop()
hydro.stop()
def integrate_single_particle_in_potential(sun, t_end, dt):
MWG = MilkyWay_galaxy()
cluster_gravity = drift_without_gravity(sun)
channel_from_gravity_to_framework \
= cluster_gravity.particles.new_channel_to(sun)
gravity = bridge.Bridge(use_threading=False)
gravity.add_system(cluster_gravity, (MWG, ))
t_orb = 2 * numpy.pi * sun.position.length() / sun.velocity.length()
gravity.timestep = min(dt, 10 | units.Myr)
x, y = evolve_cluster_in_potential(gravity, t_end, dt,
[channel_from_gravity_to_framework])
gravity.stop()
return x, y
def gravity_hydro_bridge(Mprim, Msec, a, ecc, t_end, n_steps, Rgas, Mgas,
Ngas):
stars = new_binary_from_orbital_elements(Mprim,
Msec,
a,
ecc,
G=constants.G)
eps = 1 | units.RSun
gravity = Gravity(ph4, stars, eps)
converter = nbody_system.nbody_to_si(1.0 | units.MSun, Rgas)
ism = new_plummer_gas_model(Ngas, convert_nbody=converter)
ism.move_to_center()
ism = ism.select(lambda r: r.length() < 2 * a, ["position"])
hydro = Hydro(Fi, ism, eps)
model_time = 0 | units.Myr
filename = "gravhydro.hdf5"
write_set_to_file(stars.savepoint(model_time), filename, 'amuse')
write_set_to_file(ism, filename, 'amuse')
gravhydro = bridge.Bridge(use_threading=False)
gravhydro.add_system(gravity, (hydro, ))
gravhydro.add_system(hydro, (gravity, ))
gravhydro.timestep = 2 * hydro.get_timestep()
while model_time < t_end:
orbit = orbital_elements_from_binary(stars, G=constants.G)
a = orbit[2]
ecc = orbit[3]
dE_gravity = gravity.initial_total_energy / gravity.total_energy
dE_hydro = hydro.initial_total_energy / hydro.total_energy
print "Time:", model_time.in_(units.yr), "ae=", a.in_(
units.AU), ecc, "dE=", dE_gravity, dE_hydro
model_time += 10 * gravhydro.timestep
gravhydro.evolve_model(model_time)
gravity.copy_to_framework()
hydro.copy_to_framework()
write_set_to_file(stars.savepoint(model_time), filename, 'amuse')
write_set_to_file(ism, filename, 'amuse')
gravity.stop()
hydro.stop()
def test4(self):
print "Bridge evolve_model"
convert = nbody_system.nbody_to_si(1.e5 | units.MSun,
1.0 | units.parsec)
epsilon = 1.0e-2 | units.parsec
test_class = ExampleGravityCodeInterface
numpy.random.seed(12345)
stars = new_plummer_model(100, convert_nbody=convert)
cluster = test_class()
cluster.initialize_code()
cluster.parameters.epsilon_squared = epsilon**2
cluster.particles.add_particles(stars)
cluster.commit_particles()
first_half = stars.select_array(lambda x: (x > 0 | units.m), ['x'])
second_half = stars - first_half
cluster1 = system_from_particles(test_class, dict(), first_half,
epsilon)
cluster2 = system_from_particles(test_class, dict(), second_half,
epsilon)
bridgesys = bridge.Bridge()
bridgesys.add_system(cluster1, (cluster2, ))
bridgesys.add_system(cluster2, (cluster1, ))
self.assertAlmostRelativeEqual(
cluster1.particles.get_intersecting_subset_in(
cluster.particles).position, cluster1.particles.position)
#~ old = cluster1.particles.position
for i in range(2):
one_timestep = cluster.next_timestep
cluster.evolve_model(cluster.model_time + one_timestep)
bridgesys.evolve_model(bridgesys.model_time + one_timestep,
timestep=one_timestep)
#~ print ((old - cluster1.particles.position)/old).lengths()
self.assertAlmostRelativeEqual(
cluster1.particles.get_intersecting_subset_in(
cluster.particles).position, cluster1.particles.position)
self.assertAlmostRelativeEqual(cluster.potential_energy,
bridgesys.potential_energy)
self.assertAlmostRelativeEqual(cluster.kinetic_energy,
bridgesys.kinetic_energy)
def evolve_cluster_in_galaxy(N, Mcluster, Rcluster, Rinit, Vinit, galaxy_code,
dt, dtout, tend, epsilon):
#Setup cluster
stars, converter = setup_cluster(N, Mcluster, Rcluster, Rinit, Vinit)
stars.scale_to_standard(convert_nbody=converter,
smoothing_length_squared=epsilon**2)
cluster_code = Nbody6xx(converter, number_of_workers=1)
cluster_code.initialize_code()
cluster_code.particles.add_particles(stars)
cluster_code.commit_particles()
#Setup channels between stars particle dataset and the cluster code
channel_from_stars_to_cluster_code = stars.new_channel_to(
cluster_code.particles,
attributes=["mass", "x", "y", "z", "vx", "vy", "vz"])
channel_from_cluster_code_to_stars = cluster_code.particles.new_channel_to(
stars, attributes=["mass", "x", "y", "z", "vx", "vy", "vz"])
#Setup gravity bridge
gravity = bridge.Bridge(use_threading=False)
#stars in cluster_code depend on gravity from galaxy_code
gravity.add_system(cluster_code, (galaxy_code, ))
#galaxy_code still needs to be added to system so it evolves with time
gravity.add_system(galaxy_code, )
#Set how often to update external potential
gravity.timestep = dt / 2.
time = 0.0 | tend.unit
gravity.evolve_model(tend)
time = gravity.model_time
#Copy back to stars for final dataset
channel_from_cluster_code_to_stars.copy()
gravity.stop()
return stars
def __init__(
self,
*,
internal_bridges={},
timestep=None,
use_threading=True,
**systems,
):
"""Initialize a Systems instance."""
super().__init__()
# save inputs
self._use_threading = use_threading
self._init_internal_bridges = internal_bridges
self._init_timestep = timestep
self.gravity = bridge.Bridge(use_threading=use_threading)
self.system_list = set() # system list set
for k, v in systems.items():
self[k] = v
# now do bridges. needed to create systems first
self.bridge_internal_systems(bridges=internal_bridges,
timestep=timestep)
def integrate_cluster_and_GMCs_in_potential(sun, GMCs, t_end, dt, filename):
MWG = MilkyWay_galaxy()
GMC_gravity = drift_without_gravity(GMCs)
channels = []
channels.append(GMC_gravity.particles.new_channel_to(GMCs))
converter = nbody_system.nbody_to_si(sun.mass.sum(),
sun[0].position.length())
cluster_gravity = BHTree(converter)
cluster_gravity.particles.add_particles(sun)
channels.append(cluster_gravity.particles.new_channel_to(sun))
gravity = bridge.Bridge(use_threading=False)
gravity.add_system(cluster_gravity, (MWG, GMC_gravity))
gravity.add_system(GMC_gravity, (MWG, ))
gravity.timestep = min(dt, 10 | units.Myr)
t_orb = 2 * numpy.pi * sun.position.length() / sun.velocity.length()
gravity.timestep = min(dt, 10 | units.Myr)
x, y = evolve_cluster_in_potential(gravity, t_end, dt, channels, sun, GMCs,
filename)
gravity.stop()
return x, y
def main(t_end, filename):
bodies = Particles(2)
Sun = bodies[0]
Sun.mass = 1 | units.MSun
Sun.position = (8.4, 0.0, 0.0) | units.kpc
Sun.velocity = (-10.1, 235.5, 7.5) | units.kms # SPZ2009
M67 = bodies[1]
M67.mass = 50000 | units.MSun
M67.position = Sun.position + ((0.766, 0.0, 0.49) | units.kpc)
M67.velocity = Sun.velocity + ((31.92, -21.66, -8.71) | units.kms)
converter = nbody_system.nbody_to_si(bodies.mass.sum(), Sun.x)
sunandm67 = Huayno(converter)
sunandm67.particles.add_particle(bodies)
channel_from_sunandm67 = sunandm67.particles.new_channel_to(bodies)
gravity = bridge.Bridge()
gravity.add_system(sunandm67, (MilkyWay_galaxy(), ))
dt = 1 | units.Myr
gravity.timestep = dt
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot_prev = Etot_init
t_end = 4.5 | units.Gyr
time = 0 * t_end
if filename:
write_set_to_file(bodies.savepoint(0.0 | t_end.unit),
filename,
"hdf5",
append_to_file=False)
pyplot.draw()
else:
R = [] | units.kpc
for bi in bodies:
R.append(bi.position.length())
pyplot.ion()
pyplot.scatter(R.value_in(units.kpc),
bodies.z.value_in(units.kpc),
c=['k', 'r'],
s=10,
lw=0)
pyplot.xlabel("R [kpc]")
pyplot.ylabel("Z [kpc]")
while time < t_end:
time += dt
gravity.evolve_model(time)
channel_from_sunandm67.copy()
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
print "T=", time, "M=", bodies.mass.sum(),
print "E= ", Etot, "Q= ", Ekin / Epot,
print "dE=", (Etot_init - Etot) / Etot, "ddE=", (Etot_prev -
Etot) / Etot
Etot_prev = Etot
if filename:
write_set_to_file(bodies.savepoint(time), filename, "hdf5")
else:
R = [] | units.kpc
for bi in bodies:
R.append(bi.position.length())
pyplot.scatter(R.value_in(units.kpc),
bodies.z.value_in(units.kpc),
c=['k', 'r'],
s=10,
lw=0)
pyplot.draw()
gravity.stop()
omega_bar=OB,
amplitude=A,
m=m,
mass_bar=M)
sun_pos = [-8400.0, 0.0, 17.0] | units.parsec
MWG = inte.galaxy()
vc = MWG.get_velcirc(sun_pos[0], sun_pos[1], sun_pos[2])
sun_vel = [11.352, (12.24 + vc.value_in(units.kms)), 7.41] | units.kms
star_cluster.position += sun_pos
star_cluster.velocity += sun_vel
cluster_gravity, channels = setup_multi_bridge_system(star_cluster)
gravity = bridge.Bridge(use_threading=False)
gravity.add_system(cluster_gravity, (MWG, ))
t_orb = 2 * numpy.pi * sun_pos.length() / sun_vel.length()
t_end = 100 | units.day
gravity.timestep = min(0.1 * t_end, 0.01 * t_orb)
"""
sun_pos = [-8400.0, 0.0, 17.0] | units.parsec
MWG = MilkyWay_galaxy()
vc = MWG.vel_circ(sun_pos.length())
sun_vel = [11.352, (12.24+vc.value_in(units.kms)), 7.41] | units.kms
star_cluster.position += sun_pos
star_cluster.velocity += sun_vel
cluster_gravity, channels = setup_multi_bridge_system(star_cluster)
def evolve_disk_flyby(stars,
planetesimals,
stars_gravity,
planetesimals_gravity,
t_start,
t_end,
n_steps,
converter,
snap_dir,
file_out,
r_step,
bridge_dt,
center=0):
"""
Input Parameters:
stars --- Star bodies
planetesimals --- Non-star bodies
stars_gravity ---
planetesimals_gravity ---
t_end --- Total Integration Time
n_steps --- Number of Snapshots
converter ---
snap_dir ---
file_out ---
r_step ---
bridge_dt --- Bridge Timestep
"""
bodies = ParticlesSuperset([stars, planetesimals])
channel_from_stars_to_framework = stars_gravity.particles.new_channel_to(
stars)
channel_from_planetesimals_to_framework = planetesimals_gravity.particles.new_channel_to(
planetesimals)
pl_gravity = planet_gravity_for_disk(Huayno,
stars_gravity.particles,
converter,
center=center)
gravity = bridge.Bridge(use_threading=False)
gravity.add_system(planetesimals_gravity,
(pl_gravity, )) # stars work on planetesimals
gravity.add_system(stars_gravity,
()) # stars are self aware (evolves itself)
# timestep for BRIDGE relative to the period at r_step (or r_min, if no r_step is given)
# BRIDGE_timestep = bridge_dt * P(r_step)
if r_step is None:
Porb_min = orbital_period((bodies[2:].position.lengths()).min(),
bodies[0].mass)
print " ** P_min_disk = ", Porb_min.in_(units.yr)
gravity.timestep = bridge_dt * Porb_min
else:
Porb_min = orbital_period(r_step, bodies[0].mass)
print " ** P_rin_disk = ", Porb_min.in_(units.yr)
gravity.timestep = bridge_dt * Porb_min
time_step = stars_gravity.get_timestep_parameter()
print ' ** timesteps: \t stars gravity timestep parameter =', time_step
print '\t\t bridge =', gravity.timestep
Etot_init = stars_gravity.kinetic_energy + stars_gravity.potential_energy
Etot = Etot_init
ps.mkdir(snap_dir)
duration = t_end - t_start
dt = duration / float(n_steps)
time = 0.0 | units.yr
print "Duration:", duration, "t_start", t_start, "t_end", t_end, "dt:", dt
print " ** evolving: t_start = ", t_start.value_in(
1000 * units.yr), "t_end = ", t_end.value_in(1000 *
units.yr), ", dt = ", dt
print " \t", "time", "\t\t\t", "E", "\t\t", "dE"
stdout = (file_out.split('.'))[0]
stdout += '.txt'
f = open(snap_dir + "/" + stdout, 'a')
# Joules
J = units.m**2 * units.kg * units.s**-2
while time <= duration:
gravity.evolve_model(time)
channel_from_stars_to_framework.copy()
channel_from_planetesimals_to_framework.copy()
bodies.collection_attributes.timestamp = time + t_start
Ekin = stars_gravity.kinetic_energy
Epot = stars_gravity.potential_energy
Etot = Ekin + Epot
dE = Etot_init - Etot
nb_E = converter.to_nbody(Etot)
#nb_J = converter.nbody_length ** 2 * units.nbody_mass * units.nbody_time ** -2 # not supposed to work
# A formatted string would work better than tabs. (Tabs never work)
line = " \t" + str((time + t_start).value_in(
units.yr)) + "\t" + str(nb_E) + "\t" + str(dE / Etot_init)
print line
f.write(line + "\n")
# Write coordinates in Center of Mass frame
# Move Stars to CoM (initially in CoM)
#### The stars are already in CoM coordinates ####
# Move planetesimals to CoM (initially w/ respect to star zero)
planetesimals.velocity += stars[center].velocity
planetesimals.position += stars[center].position
write_set_to_file(bodies, snap_dir + "/" + file_out, "hdf5")
time += dt
f.close() # stdout
gravity.stop()
stars_gravity.stop()
planetesimals_gravity.stop()
pl_gravity.stop()
# retrieval?
return stars, planetesimals
def sim_Sun_and_siblings(N=50,
perc=0.01,
t_end=4.56 | units.Gyr,
dt_save=0.2 | units.Myr,
dt=0.01 | units.Myr,
pointparticles=True,
dirname='None'):
"""
Simulate Sun and siblings in the Galactic potential.
"""
if pointparticles:
"""
Create a set of point partciles to integrate around the galactic center.
"""
# for the pointparticles
if dirname == 'None': dirname = './pointparticles/'
#create outputfolder for this star
outputfolder = os.path.join(dirname)
if not os.path.exists(outputfolder):
os.makedirs(outputfolder)
# initalize bodies
bodies = Particles(N + 1)
# create the Sun
Sun = bodies[0]
Sun.mass = 1e-9 | units.kg # assume Sun is point mass moving in the
Sun.radius = 0 | units.RSun # galactic potential
Sun.velocity = (-1.35, -232.1, -7.41) | units.kms
Sun.position = (-8400, 0.0, 17.0) | units.parsec
# create a Gaussian cloud of stars as point particles
siblings = bodies[1:]
siblings.mass = 1e-9 | units.kg
siblings.radius = 0 | units.RSun
# create a cloud of particles
siblings.x = np.random.normal(Sun.x.value_in(units.parsec),
abs(Sun.x.value_in(units.parsec)) * perc,
N) | units.parsec
siblings.y = 0 | units.parsec # no spread in y-direction since we start at y=0
siblings.z = np.random.normal(Sun.z.value_in(units.parsec),
abs(Sun.z.value_in(units.parsec)) * perc,
N) | units.parsec
siblings.vx = np.random.normal(Sun.vx.value_in(units.kms),
abs(Sun.vx.value_in(units.kms)) * perc,
N) | units.kms
siblings.vy = np.random.normal(Sun.vy.value_in(units.kms),
abs(Sun.vy.value_in(units.kms)) * perc,
N) | units.kms
siblings.vz = np.random.normal(Sun.vz.value_in(units.kms),
abs(Sun.vz.value_in(units.kms)) * perc,
N) | units.kms
# Integrator
converter = nbody_system.nbody_to_si(bodies.mass.sum(), Sun.x)
bodies.velocity *= -1 # Integrate backwards in time
# integrator to use
system = ph4(converter)
else:
"""
Create an open star cluster to integrate around the galactic center.
"""
# if dirname not specified
if dirname == 'None': dirname = './opencluster/'
#create outputfolder for this star
outputfolder = os.path.join(dirname)
if not os.path.exists(outputfolder):
os.makedirs(outputfolder)
# parameters to use
Rvir = 1.0 | units.parsec
Qvir = 0.5
# create masses
Mmax = 100 | units.MSun
masses = new_kroupa_mass_distribution(
N + 1, Mmax) # cluster with N other stars
Mtot_init = masses.sum()
converter = nbody_system.nbody_to_si(Mtot_init, Rvir)
# assign particles
bodies = new_plummer_model(N + 1, converter)
bodies.scale_to_standard(converter, virial_ratio=Qvir)
bodies.mass = masses
Sun = bodies[0]
Sun.mass = 1 | units.MSun # first body becomes the Sun
bodies.radius = 0 | units.RSun
bodies.velocity += (30.6471439995, -200.098514469, 2.52218463835
) | units.kms # our birthplace of the Sun
bodies.position += (9499.1059096, 1999.79260586,
80.1313697564) | units.parsec
# integrator with softening length scale
system = BHTree(converter)
system.parameters.epsilon_squared = (1 | units.parsec)**2
system.particles.add_particle(bodies)
channel_from_system = system.particles.new_channel_to(bodies)
gravity = bridge.Bridge()
gravity.add_system(system, (MilkyWay_galaxy(), ))
gravity.timestep = dt
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot_prev = Etot_init
# duration of simulation
time = 0 | units.yr
time_save = 0 | units.yr
# allocate memory for positions and velocities
x = []
y = []
z = []
vx = []
vy = []
vz = []
while time < t_end:
print 'Integrating...', time
time += dt
time_save += dt
gravity.evolve_model(time)
channel_from_system.copy()
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
print "T=", time, "M=", bodies.mass.sum(),
print "E= ", Etot, "Q= ", Ekin / Epot,
print "dE=", (Etot_init - Etot) / Etot, "ddE=", (Etot_prev -
Etot) / Etot
Etot_prev = Etot
if time_save > dt_save:
# save the postion and velocities of all objects
x = np.append(x, bodies.x.value_in(units.parsec))
y = np.append(y, bodies.y.value_in(units.parsec))
z = np.append(z, bodies.z.value_in(units.parsec))
vx = np.append(vx, bodies.vx.value_in(units.kms))
vy = np.append(vy, bodies.vy.value_in(units.kms))
vz = np.append(vz, bodies.vz.value_in(units.kms))
print 'Appended velocities and positions.'
# reset timer
time_save = 0 | units.yr
# explicitly save last position
x = np.append(x, bodies.x.value_in(units.parsec))
y = np.append(y, bodies.y.value_in(units.parsec))
z = np.append(z, bodies.z.value_in(units.parsec))
vx = np.append(vx, bodies.vx.value_in(units.kms))
vy = np.append(vy, bodies.vy.value_in(units.kms))
vz = np.append(vz, bodies.vz.value_in(units.kms))
print 'Appended final postions.'
gravity.stop()
# Correct the inverse velocity
if pointparticles: bodies.velocity *= -1
# plot the positions of all particles
x = x.reshape((N + 1, x.size / (N + 1)))
y = y.reshape((N + 1, y.size / (N + 1)))
z = z.reshape((N + 1, z.size / (N + 1)))
vx = vx.reshape((N + 1, vx.size / (N + 1)))
vy = vy.reshape((N + 1, vy.size / (N + 1)))
vz = vz.reshape((N + 1, vz.size / (N + 1)))
# save positions seperately
np.save(os.path.join(dirname, 'x.npy'), x)
np.save(os.path.join(dirname, 'y.npy'), y)
np.save(os.path.join(dirname, 'z.npy'), z)
np.save(os.path.join(dirname, 'vx.npy'), vx)
np.save(os.path.join(dirname, 'vy.npy'), vy)
np.save(os.path.join(dirname, 'vz.npy'), vz)
print 'Saved velocities and positions.'
def gravity_hydro_bridge(gravity,
hydro,
sink,
local_particles,
Rmin,
t_end=1000. | units.yr,
dt=10. | units.yr):
# Set the local particles in each system
gravity_particles, disk_star, disk_gas = local_particles
Sun = disk_star[0]
Jupiter = gravity_particles[0]
PassStar = gravity_particles[1]
Mstar = Sun.mass.in_(units.MSun)
Sun_and_Jupiter = Particles()
Sun_and_Jupiter.add_particle(Sun)
Sun_and_Jupiter.add_particle(Jupiter)
print 'Bridging...'
# Build up the bridge between gravity and hydrodynamics
grav_hydro = bridge.Bridge(use_threading=False)
grav_hydro.add_system(gravity, (hydro, ))
grav_hydro.add_system(hydro, (gravity, ))
grav_hydro.timestep = dt
# Set up channels for updating the particles
channel_to_grav = gravity.particles.new_channel_to(gravity_particles)
channel_from_grav = gravity_particles.new_channel_to(gravity.particles)
channel_to_hydro_gas = hydro.gas_particles.new_channel_to(disk_gas)
channel_from_hydro_gas = disk_gas.new_channel_to(hydro.gas_particles)
channel_to_hydro_star = hydro.dm_particles.new_channel_to(disk_star)
chennel_from_hydro_star = disk_star.new_channel_to(hydro.dm_particles)
# Sanity checks:
print('Sanity checks:')
print('Sun coordinates (AU)', Sun.x.value_in(units.AU),
Sun.y.value_in(units.AU), Sun.z.value_in(units.AU))
print('Jupiter coordinates (AU)', Jupiter.x.value_in(units.AU),
Jupiter.y.value_in(units.AU), Jupiter.z.value_in(units.AU))
print('Disk particle map saved to: initial_check_disk.png')
plot_map(hydro, [Sun, Jupiter, PassStar], N=400, L=400,\
title='initial_check_disk.png', show=True)
times = list(
np.arange(0.0,
t_end.value_in(units.yr) + dt.value_in(units.yr),
dt.value_in(units.yr)))
a_Jup = list()
e_Jup = list()
disk_size = list()
accreted_mass = list()
# start evolotuion
print 'Start evolving...'
model_time = 0.0 | units.yr
while model_time <= t_end:
# Save the data for plots
orbit = orbital_elements_from_binary(Sun_and_Jupiter, G=constants.G)
a = orbit[2].value_in(units.AU)
e = orbit[3]
lr9 = return_L9_radius(disk_gas, Mstar, Rmin)
a_Jup.append(a)
e_Jup.append(e)
disk_size.append(lr9)
accreted_mass.append((sink.mass).value_in(units.MJupiter)[0])
#if model_time.value_in(units.yr) % 50 == 0:
print 'Time = %.1f yr:'%model_time.value_in(units.yr), \
'a = %.2f au, e = %.3f,'%(a, e), \
'disk size = %.2f au'%lr9, \
'accreted mass = %.2f M_Jupiter'%sink.mass.value_in(units.MJupiter)
plot_map(hydro, [Sun, Jupiter, PassStar], N=400, L=400,\
title='test_plots/%d.png'%model_time.value_in(units.yr), show=False)
# Evolve the bridge system for one step
model_time += dt
grav_hydro.evolve_model(model_time)
channel_to_grav.copy()
channel_to_hydro_gas.copy()
channel_to_hydro_star.copy()
# Add the 'sinked' mass to Jupiter & keep the sink particle along with Jupiter
removed_particles = hydro_sink_particles(sink, disk_gas)
Jupiter.mass += sink.mass
sink.position = Jupiter.position
sink.radius = a * (1 - e) * (
(1.0 | units.MJupiter).value_in(units.MSun) / 3.)**(1. /
3.) | units.au
channel_from_grav.copy()
gravity.stop()
hydro.stop()
return times, a_Jup, e_Jup, disk_size, accreted_mass
def gravity_hydro_bridge(gravity,
hydro,
local_particles,
Rmin,
t_end=1000. | units.yr,
dt=10. | units.yr):
Sun_and_Jupiter, disk_gas = local_particles
Mstar = gravity.particles[1].mass.in_(units.MSun)
print 'Bridging...'
# build up the bridge between gravity and hydrodynamics
grav_hydro = bridge.Bridge(use_threading=False)
grav_hydro.add_system(gravity, (hydro, ))
grav_hydro.add_system(hydro, (gravity, ))
#grav_hydro.timestep = dt
# set up channels for updating the particles
channel_from_grav = gravity.particles.new_channel_to(Sun_and_Jupiter)
channel_from_hydro = hydro.gas_particles.new_channel_to(disk_gas)
a_Jup = list()
e_Jup = list()
disk_size = list()
# start evolotuion
print 'Start evolving...'
times = quantities.arange(0. | units.yr, t_end + 1 * dt, 2 * dt)
model_time = 0.0 | units.yr
while model_time <= t_end:
# save the data for plots
orbit = orbital_elements_from_binary(Sun_and_Jupiter, G=constants.G)
a = orbit[2].value_in(units.AU)
e = orbit[3]
lr9 = return_L9_radius(disk_gas, Mstar, Rmin | units.AU)
a_Jup.append(a)
e_Jup.append(e)
disk_size.append(lr9)
if model_time.value_in(units.yr) % 50 == 0:
print 'Time = %.1f yr:'%model_time.value_in(units.yr), \
'a = %.2f au, e = %.2f,'%(a, e), \
'disk size = %.2f au'%lr9
# evolve the bridge system for one step
model_time += dt
grav_hydro.evolve_model(model_time, timestep=2 * dt)
channel_from_grav.copy()
channel_from_hydro.copy()
# add the 'sinked' mass to Jupiter & keep the sink particle along with Jupiter
sink = hydro.particles[0]
_ = hydro_sink_particles([sink], disk_gas)
Jupiter = gravity.particles[1]
Jupiter.mass += sink.mass
sink.position = Jupiter.position
sink.radius = a * (1 - e) * (
(1.0 | units.MJupiter).value_in(units.MSun) / 3.)**(1. /
3.) | units.au
channel_from_grav.copy()
channel_from_hydro.copy()
gravity.stop()
hydro.stop()
return a_Jup, e_Jup, disk_size, times
# In[11]:
gravity1 = ph4(converter)
gravity1.particles.add_particles(galaxies)
channel = {"from_galaxies": galaxies.new_channel_to(gravity1.particles),
"to_galaxies": gravity1.particles.new_channel_to(galaxies)}
channel.update({"from_gas": sph_code.gas_particles.new_channel_to(sph_code.particles)})
channel.update({"to_gas": sph_code.particles.new_channel_to(sph_code.gas_particles)})
galaxies.add_particles(sph_code.gas_particles)
from amuse.couple import bridge
from amuse.ext.composition_methods import *
gravhydro = bridge.Bridge(use_threading=False) #, method=SPLIT_4TH_S_M4)
gravhydro.add_system(gravity1, (sph_code,))
gravhydro.add_system(sph_code, (gravity1,))
gravhydro.timestep = 5.0 | units.Myr
# In[ ]:
def gravity_hydro_bridge(gravity, hydro, gravhydro, galaxies,
t_end):
model_time = 0 | units.Myr
dt = 10|units.Myr #1.0*Pinner
while model_time < t_end:
def gravity_hydro_bridge(gravity,
hydro,
sink,
local_particles,
Rmin,
t_end=1000. | units.yr,
dt=10. | units.yr):
Sun_and_Jupiter, disk_gas = local_particles
Mstar = 1.0 | units.MSun
print 'Bridging...'
# Build up the bridge between gravity and hydrodynamics
grav_hydro = bridge.Bridge(use_threading=False)
grav_hydro.add_system(gravity, (hydro, ))
grav_hydro.add_system(hydro, (gravity, ))
grav_hydro.timestep = dt
# Set up channels for updating the particles
channel_from_grav = gravity.particles.new_channel_to(Sun_and_Jupiter)
channel_from_hydro = hydro.gas_particles.new_channel_to(disk_gas)
channel_to_grav = Sun_and_Jupiter.new_channel_to(gravity.particles)
channel_to_hydro = disk_gas.new_channel_to(hydro.gas_particles)
# Preparing lists for data-recording
a_Jup = []
e_Jup = []
disk_size = []
accreted_mass = []
accreted_mass.append((sink.mass).value_in(units.MJupiter)[0])
sink0_mass = 0 | units.MJupiter
# Start evolution
print 'Start evolving...'
times = quantities.arange(0. | units.yr, t_end + 1 * dt, dt)
model_time = 0.0 | units.yr
while model_time <= t_end:
# Save the data for plots
orbit = orbital_elements_from_binary(Sun_and_Jupiter, G=constants.G)
a = orbit[2].value_in(units.AU)
e = orbit[3]
lr9 = return_L9_radius(disk_gas, Mstar, Rmin | units.AU)
a_Jup.append(a)
e_Jup.append(e)
disk_size.append(lr9)
am = (sink.mass[0]).value_in(units.MJupiter)
accreted_mass.append(am)
# Plotting system
print 'Time = %.1f yr:'%model_time.value_in(units.yr), \
'a = %.2f au, e = %.2f,'%(a, e), \
'disk size = %.2f au'%lr9
plot_map(hydro,
Sun_and_Jupiter,
'{0}'.format(int(model_time.value_in(units.yr))),
show=False)
# Evolve the bridge system for one step
model_time += dt
grav_hydro.evolve_model(model_time)
channel_from_grav.copy()
channel_from_hydro.copy()
# Calculating accreted mass in new position
Jupiter = gravity.particles[0]
sink.position = Jupiter.position
sink.radius = Hill_radius(a, e, Sun_and_Jupiter) | units.AU
removed_particles = hydro_sink_particles(sink, disk_gas)
Jupiter.mass += sink.mass - sink0_mass
sink0_mass = sink.mass.copy()
channel_to_grav.copy()
channel_to_hydro.copy()
gravity.stop()
hydro.stop()
return a_Jup, e_Jup, disk_size, times, accreted_mass
def simulation():
Hercules = Particles(1)
Hercules.mass = 6e5 | units.MSun
RA, DEC = 250.422, 36.460 #degrees
D = 7.1 #distance from Sun, kpc
vlos = -244.49 # pm 0.43, line-of-sight velocity in km/s
mu_RA = -106.6 #pm 1.6, proper motion in km/s
mu_DEC = -87.2 #pm 1.6, proper motion in km/s
#will need to fix this
Hercules.position = (20., 0., 0.) | units.kpc
Hercules.velocity = (0., 200., 0.) | units.kms
gravity = bridge.Bridge(use_threading=False)
gravity_Hercules = Hermite()
gravity_Hercules.particles.add_particles(Hercules)
potential = KuzminKutuzovStaeckelPotential
galaxy_code = to_amuse(potential,
t=0.0,
tgalpy=0.0,
reverse=False,
ro=None,
vo=None)
gravity.add_system(gravity_Hercules, galaxy_code)
channel_from_gravity_to_framework = gravity.particles.new_channel_to(
Hercules)
channel_from_framework_to_gravity = Hercules.new_channel_to(
gravity.particles)
tend, dt = 1000. | units.Myr, 5. | units.Myr
sim_times_unitless = np.arange(
0.,
tend.value_in(units.Myr) + dt.value_in(units.Myr),
dt.value_in(units.Myr))
sim_times = [t | units.Myr for t in sim_times_unitless]
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
rvals, zvals = [], []
for j, t in enumerate(sim_times):
x_gal = gravity.particles.position[0].value_in(units.kpc)
y_gal = gravity.particles.position[0].value_in(units.kpc)
z_gal = gravity.particles.position[0].value_in(units.kpc)
r_gal = np.sqrt(x_gal**2 + y_gal**2)
rvals.append(r_gal)
zvals.append(z_gal)
plt.figure()
plt.plot(rvals, zvals, c='k', label='M13')
plt.legend(loc='upper right')
plt.xlim(0., 50.)
plt.ylim(-20., 20.)
plt.xlabel('$r_{\mathrm{gal}}$ (kpc)', fontsize=14)
plt.ylabel('$z_{\mathrm{gal}}$ (kpc)', fontsize=14)
plt.savefig('m13_trajectory_%s.png' % (str(j).rjust(5, '0')))
plt.close()
gravity.evolve_model(t)
gravity.stop()
return 0
def main(Mstar, Ndisk, fmdisk, Rmin, Rmax, t_end, n_steps):
Mdisk = fmdisk * Mstar
converter=nbody_system.nbody_to_si(Mstar, Rmax)
star_and_planets, disk = initialize_star_and_planetary_system(Mstar, Ndisk, Mdisk, Rmin, Rmax)
hydro=Fi(converter)
# hydror = Fi(channel_type="ibis", hostname="galgewater")
hydro.parameters.use_hydro_flag=True
hydro.parameters.radiation_flag=False
hydro.parameters.self_gravity_flag=True
hydro.parameters.gamma=1.
hydro.parameters.isothermal_flag=True
hydro.parameters.integrate_entropy_flag=False
hydro.parameters.timestep=0.125 | units.yr
hydro.gas_particles.add_particles(disk)
gravity = Hermite(converter)
gravity.particles.add_particles(star_and_planets)
planet_attributes=["x", "y", "z", "vx", "vy", "vz", "mass", "semimajor_axis", "eccentricity"]
disk_attributes=["x", "y", "z", "vx", "vy", "vz", "mass", "u", "rho", "h_smooth"]
channel_to_planets = gravity.particles.new_channel_to(star_and_planets)
channel_from_hydro_to_framework = hydro.particles.new_channel_to(disk,
attributes=disk_attributes)
channel_from_hydro_to_framework.copy()
moving_bodies = ParticlesSuperset([star_and_planets, disk])
moving_bodies.move_to_center()
index = 0
filename = "planetary_system_i{0:04}.amuse".format(index)
write_set_to_file(star_and_planets, filename, 'amuse', attribute_names=planet_attributes,
append_to_file=False)
write_set_to_file(disk, filename, 'amuse', attribute_names=disk_attributes)
gravity_hydro = bridge.Bridge(use_threading=False)
gravity_hydro.add_system(gravity, (hydro,) )
gravity_hydro.add_system(hydro, (gravity,) )
Etot_init = gravity_hydro.kinetic_energy + gravity_hydro.potential_energy
Etot_prev = Etot_init
time = 0.0 | t_end.unit
dt = t_end/float(n_steps)
gravity_hydro.timestep = dt/10.
while time < t_end:
time += dt
gravity_hydro.evolve_model(time)
Etot_prev_se = gravity_hydro.kinetic_energy + gravity_hydro.potential_energy
channel_to_planets.copy()
channel_from_hydro_to_framework.copy()
for pi in star_and_planets[1:]:
a, e = calculate_orbital_elements(star_and_planets[0], pi)
pi.semimajor_axis = a
pi.eccentricity = e
index += 1
filename = "planetary_system_i{0:04}.amuse".format(index)
write_set_to_file(star_and_planets, filename, 'amuse', attribute_names=planet_attributes,
append_to_file=False)
write_set_to_file(disk, filename, 'amuse', attribute_names=disk_attributes)
Ekin = gravity_hydro.kinetic_energy
Epot = gravity_hydro.potential_energy
Etot = Ekin + Epot
print "T=", time,
print "E= ", Etot, "Q= ", Ekin/Epot,
print "dE=", (Etot_init-Etot)/Etot, "ddE=", (Etot_prev-Etot)/Etot
Etot_prev = Etot
gravity_hydro.stop()
def evolve_cluster_in_galaxy(N, Rcluster, Rinit, Vinit, galaxy_code, dt, dtout,
tend, epsilon):
#Setup cluster
masses = new_kroupa_mass_distribution(N)
Mcluster = masses.sum()
#Create star cluster with origin at 0,0,0 and no net velocity
converter = nbody_system.nbody_to_si(Mcluster, Rcluster)
stars = new_plummer_sphere(N, converter)
#Place star cluster in Galactocentric position
stars.x += Rinit[0]
stars.y += Rinit[1]
stars.z += Rinit[2]
stars.vx += Vinit[0]
stars.vy += Vinit[1]
stars.vz += Vinit[2]
stars.mass = masses
stars.scale_to_standard(convert_nbody=converter,
smoothing_length_squared=epsilon**2)
#Gravity code
cluster_code = BHTree(
converter, number_of_workers=1
) #Change number of workers depending on CPUS available
cluster_code.parameters.epsilon_squared = epsilon**2
cluster_code.parameters.opening_angle = 0.6
cluster_code.parameters.timestep = dt
#cluster_code.particles.add_particles(stars)
#Setup channels between stars particle dataset and the cluster code
channel_from_stars_to_cluster_code = stars.new_channel_to(
cluster_code.particles,
attributes=["mass", "x", "y", "z", "vx", "vy", "vz"])
channel_from_cluster_code_to_stars = cluster_code.particles.new_channel_to(
stars, attributes=["mass", "x", "y", "z", "vx", "vy", "vz"])
#Stellar evolution code
stellar_evolution = SSE()
stellar_evolution.particles.add_particle(stars)
#Setup channels between stars particle dataset and stellar evolution code
channel_from_stars_to_stellar_evolution = stars.new_channel_to(
stellar_evolution.particles, attributes=["mass"])
channel_from_stellar_evolution_to_stars = stellar_evolution.particles.new_channel_to(
stars, attributes=["mass"])
#Setup gravity bridge
gravity = bridge.Bridge(use_threading=False)
#stars in cluster_code depend on gravity from galaxy_code
gravity.add_system(cluster_code, (galaxy_code, ))
#galaxy_code still needs to be added to system so it evolves with time
gravity.add_system(galaxy_code, )
#Set how often to update external potential
gravity.timestep = cluster_code.parameters.timestep / 2.
time = 0.0 | tend.unit
first = True
while time < tend:
print(time.value_in(units.Myr), tend.value_in(units.Myr),
stars.mass.sum().value_in(units.MSun))
stellar_evolution.evolve_model(time + dt / 2.)
channel_from_stellar_evolution_to_stars.copy_attributes(["mass"])
if first:
cluster_code.particles.add_particles(stars)
first = False
else:
channel_from_stars_to_cluster_code.copy_attributes(["mass"])
gravity.evolve_model(time + dt)
channel_from_cluster_code_to_stars.copy()
stellar_evolution.evolve_model(time + dt)
channel_from_stellar_evolution_to_stars.copy_attributes(["mass"])
channel_from_stars_to_cluster_code.copy_attributes(["mass"])
#You need to copy stars from cluster_code to output or analyse:
#channel_from_cluster_code_to_stars.copy()
#Output/Analyse
#If you edited the stars particle set, lets say to remove stars from the array because they have
#been kicked far from the cluster, you need to copy the array back to cluster_code:
#channel_from_stars_to_cluster_code.copy()
time = gravity.model_time
#Copy back to stars for final dataset
channel_from_cluster_code_to_stars.copy()
gravity.stop()
return stars
