def test10(self):
print "Testing MI6 collision_detection"
particles = Particles(7)
particles.mass = 0.00000001 | nbody_system.mass
particles.radius = 0.0001 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]] * 3 + [[-4, 0, 0]] | nbody_system.speed
instance = MI6(**default_options)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertAlmostEquals(
instance.model_time, -(particles[0].x - particles[1].x) / (particles[0].vx - particles[1].vx), 3
)
self.assertEquals(len(collisions.particles(0)), 3)
self.assertEquals(len(collisions.particles(1)), 3)
self.assertEquals(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEquals(
abs(collisions.particles(0).x - collisions.particles(1).x)
< (collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True],
)
sticky_merged = Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print instance.model_time
print instance.particles
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print
print instance.model_time
print instance.particles
self.assertTrue(collisions.is_set())
self.assertAlmostEquals(
instance.model_time, -(particles[6].x - 0.5 * (particles[4].x + particles[5].x)) / particles[6].vx, 3
)
self.assertEquals(len(collisions.particles(0)), 1)
self.assertEquals(len(collisions.particles(1)), 1)
self.assertEquals(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEquals(
abs(collisions.particles(0).x - collisions.particles(1).x)
< (collisions.particles(0).radius + collisions.particles(1).radius),
[True],
)
instance.stop()
def xtest10(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print "Testing Sakura collision_detection"
particles = Particles(7)
particles.mass = 0.00000001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]] * 3 + [[-4, 0, 0]] | nbody_system.speed
instance = Sakura()
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEquals(len(collisions.particles(0)), 3)
self.assertEquals(len(collisions.particles(1)), 3)
self.assertEquals(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEquals(
abs(collisions.particles(0).x - collisions.particles(1).x)
< (collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True],
)
sticky_merged = Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print instance.model_time
print instance.particles
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print
print instance.model_time
print instance.particles
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEquals(len(collisions.particles(0)), 1)
self.assertEquals(len(collisions.particles(1)), 1)
self.assertEquals(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEquals(
abs(collisions.particles(0).x - collisions.particles(1).x)
< (collisions.particles(0).radius + collisions.particles(1).radius),
[True],
)
instance.stop()
def xtest10(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan collision_detection")
particles = Particles(7)
particles.mass = 0.00000001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = self.new_instance_of_an_optional_code(Tupan)
instance.initialize_code()
instance.parameters.set_defaults()
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print(instance.model_time)
print(instance.particles)
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print()
print(instance.model_time)
print(instance.particles)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEqual(abs(collisions.particles(0).x - collisions.particles(1).x) <
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test3(self):
print "Testing SinkParticles initialization from existing particles in set"
particles = Particles(10)
self.assertRaises(AttributeError, SinkParticles, particles[[4, 7]], expected_message=
"You tried to access attribute 'radius' but this attribute is not defined for this set.")
particles.radius = 42.0 | units.RSun
particles.mass = range(1,11) | units.MSun
particles.position = [[i, 2*i, 3*i] for i in range(10)] | units.parsec
sinks = SinkParticles(particles[[4]])
self.assertEqual(sinks.mass, 5.0 | units.MSun)
self.assertEqual(sinks.sink_radius, 42.0 | units.RSun)
self.assertEqual(sinks.radius, 42.0 | units.RSun)
self.assertEqual(sinks.position, [4.0, 8.0, 12.0] | units.parsec)
sinks = SinkParticles(particles[[4, 7]], sink_radius=[1,2]|units.AU)
self.assertEqual(sinks.sink_radius, [1.0, 2.0] | units.AU)
self.assertEqual(sinks.radius, 42.0 | units.RSun)
self.assertEqual(sinks.mass, [5.0, 8.0] | units.MSun)
self.assertEqual(sinks.position, [[4, 8, 12], [7, 14, 21]] | units.parsec)
self.assertEqual(set(['key', 'mass', 'radius', 'x', 'y', 'z', 'sink_radius', 'vx','vy','vz','lx','ly','lz']),
set(str(sinks).split("\n")[0].split()))
self.assertEqual(set(['key', 'mass', 'radius', 'x', 'y', 'z']),
set(str(particles).split("\n")[0].split()))
def set_up_initial_conditions(orbital_period, kinetic_to_potential_ratio):
print("Setting up initial conditions")
stars = Particles(2)
stars.mass = [10.0, 1.0] | units.MSun
stars.radius = 0 | units.RSun
stars.position = [0.0, 0.0, 0.0] | units.AU
stars.velocity = [0.0, 0.0, 0.0] | units.km / units.s
print("Binary with masses: " + str(stars.mass) +
", and orbital period: ", orbital_period)
semimajor_axis = ((constants.G * stars.total_mass() *
(orbital_period / (2 * pi))**2.0)**(1.0 / 3.0))
separation = 2 * semimajor_axis * (1 - kinetic_to_potential_ratio)
print("Initial separation:", separation.as_quantity_in(units.AU))
relative_velocity = (
(kinetic_to_potential_ratio / (1.0 - kinetic_to_potential_ratio))
* constants.G * stars.total_mass() / semimajor_axis
).sqrt()
print("Initial relative velocity:",
relative_velocity.as_quantity_in(units.km / units.s))
stars[0].x = separation
stars[0].vy = relative_velocity
stars.move_to_center()
return stars
def test5(self):
print "Testing MI6 evolve_model, 2 particles, no SMBH"
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
print particles
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = MI6(converter, **default_options)
instance.initialize_code()
instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test4(self):
print "Testing Adaptb evolve_model, 2 particles"
particles = Particles(2)
particles.mass = 0.5 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (1.0 | units.MSun) / (1.0 | units.AU)).sqrt()
particles.move_to_center()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Adaptb, convert_nbody)
instance.initialize_code()
instance.parameters.dt_print = 0.1 | units.yr
instance.parameters.bs_tolerance = 1.0e-8
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 6)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 6)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 6)
instance.cleanup_code()
instance.stop()
def test3(self):
print("Testing SinkParticles initialization from existing particles in set")
particles = Particles(10)
self.assertRaises(AttributeError, SinkParticles, particles[[4, 7]], expected_message=
"You tried to access attribute 'radius' but this attribute is not defined for this set.")
particles.radius = 42.0 | units.RSun
particles.mass = list(range(1,11)) | units.MSun
particles.position = [[i, 2*i, 3*i] for i in range(10)] | units.parsec
sinks = SinkParticles(particles[[4]])
self.assertEqual(sinks.mass, 5.0 | units.MSun)
self.assertEqual(sinks.sink_radius, 42.0 | units.RSun)
self.assertEqual(sinks.radius, 42.0 | units.RSun)
self.assertEqual(sinks.position, [4.0, 8.0, 12.0] | units.parsec)
sinks = SinkParticles(particles[[4, 7]], sink_radius=[1,2]|units.AU)
self.assertEqual(sinks.sink_radius, [1.0, 2.0] | units.AU)
self.assertEqual(sinks.radius, 42.0 | units.RSun)
self.assertEqual(sinks.mass, [5.0, 8.0] | units.MSun)
self.assertEqual(sinks.position, [[4, 8, 12], [7, 14, 21]] | units.parsec)
self.assertEqual(set(['key', 'mass', 'radius', 'x', 'y', 'z', 'sink_radius', 'vx','vy','vz','lx','ly','lz']),
set(str(sinks).split("\n")[0].split()))
self.assertEqual(set(['key', 'mass', 'radius', 'x', 'y', 'z']),
set(str(particles).split("\n")[0].split()))
def test4(self):
print "Testing Pikachu evolve_model, 2 particles"
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Pikachu, converter, **default_options)
instance.initialize_code()
instance.parameters.timestep = 0.0125 * math.pi * particles[0].x / particles[0].vy
instance.parameters.rcut_out_star_star = 10.0 | units.AU
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def main(temperature, radius, mass, resolution, uvmatch, brmatch, verbose):
star = Particles(1)
star.mass = mass | units.MSun
star.temperature = temperature | units.K
star.radius = radius | units.RSun
metallicity = 0.02
if uvmatch==None:
uvmatch=True
if brmatch==None:
brmatch=True
eta=2
lambda_resolution=1000
resolution=resolution
sp=spectra.Spectrum(star, metallicity,eta, uvmatch, brmatch, lambda_resolution, resolution, verbose)
wavelenth = sp.lamb.number
flux = sp.flux.number
pyplot.semilogy(wavelenth, flux)
pyplot.savefig('./spectrum.png')
pyplot.show()
print "Done!"
def test1(self):
particles = Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0,0.0,0.0], [2.0,0.0,0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance = bridge.CalculateFieldForParticles(particles = particles, gravity_constant = nbody_system.G)
zero = 0.0 | nbody_system.length
print(instance.get_gravity_at_point([zero], [1.0] | nbody_system.length, [zero], [zero]))
fx, fy, fz = instance.get_gravity_at_point([zero], [1.0] | nbody_system.length, [zero], [zero])
self.assertAlmostEqual(fx, [0.0] | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy, [0.0] | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz, [0.0] | nbody_system.acceleration, 6)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point([zero], [x0], [zero], [zero])
potential1 = instance.get_potential_at_point([zero], [x1], [zero], [zero])
fx0, fy0, fz0 = instance.get_gravity_at_point([zero], [x0], [zero], [zero])
fx1, fy1, fz1 = instance.get_gravity_at_point([zero], [x1], [zero], [zero])
self.assertAlmostEqual(fy0[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz0[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy1[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz1[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0[0], 5)
self.assertAlmostEqual(potential0, potential1, 6)
def test2(self):
print("Testing SinkParticles initialization from existing particles")
original = Particles(3)
self.assertRaises(
AttributeError,
SinkParticles,
original,
expected_message=
"You tried to access attribute 'radius' but this attribute is not defined for this set."
)
original.radius = 42.0 | units.RSun
original.mass = 10.0 | units.MSun
original.position = [[i, -i, 2 * i] for i in range(3)] | units.parsec
sinks = SinkParticles(original)
self.assertEqual(sinks.sink_radius, 42.0 | units.RSun)
self.assertEqual(sinks.mass, 10.0 | units.MSun)
self.assertEqual(sinks.position,
[[0, 0, 0], [1, -1, 2], [2, -2, 4]] | units.parsec)
self.assertRaises(
AttributeError,
getattr,
sinks,
"bogus",
expected_message=
"You tried to access attribute 'bogus' but this attribute is not defined for this set."
)
def new_solar_system_for_mercury():
"""
Create initial conditions for the symplectic integrator Mercury, describing
the solar system. Returns a tuple consisting of two particle sets. The first
set contains the central particle (sun) and the second contains the planets
and Pluto (the 'orbiters'). The positions and velocities are in heliocentric
coordinates.
Defined attributes sun:
name, mass, radius, j2, j4, j6, Lx, Ly, Lz
Defined attributes orbiters:
name, mass, radius, density, x, y, z, vx, vy, vz, Lx, Ly, Lz, celimit
"""
planets = _planets_only(define_mercury_attributes=True)
centre = Particles(1)
centre.name = 'SUN'
centre.mass = 1.0 | units.MSun
centre.radius = 0.0000001 | units.AU
centre.j2 = .0001 | units.AU**2
centre.j4 = .0 | units.AU**4
centre.j6 = .0 | units.AU**6
centre.angular_momentum = [0.0, 0.0, 0.0
] | units.MSun * units.AU**2 / units.day
return centre, planets
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 set_up_initial_conditions(orbital_period, kinetic_to_potential_ratio):
print("Setting up initial conditions")
stars = Particles(2)
stars.mass = [10.0, 1.0] | units.MSun
stars.radius = 0 | units.RSun
stars.position = [0.0, 0.0, 0.0] | units.AU
stars.velocity = [0.0, 0.0, 0.0] | units.km / units.s
print("Binary with masses: "+str(stars.mass) +
", and orbital period: ", orbital_period)
semimajor_axis = ((constants.G * stars.total_mass() *
(orbital_period / (2 * pi))**2.0)**(1.0/3.0))
separation = 2 * semimajor_axis * (1 - kinetic_to_potential_ratio)
print("Initial separation:", separation.as_quantity_in(units.AU))
relative_velocity = (
(kinetic_to_potential_ratio / (1.0 - kinetic_to_potential_ratio))
* constants.G * stars.total_mass() / semimajor_axis
).sqrt()
print("Initial relative velocity:",
relative_velocity.as_quantity_in(units.km / units.s))
stars[0].x = separation
stars[0].vy = relative_velocity
stars.move_to_center()
return stars
def test1(self):
particles = Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance = bridge.CalculateFieldForParticles(particles=particles, gravity_constant=nbody_system.G)
zero = 0.0 | nbody_system.length
print instance.get_gravity_at_point([zero], [1.0] | nbody_system.length, [zero], [zero])
fx, fy, fz = instance.get_gravity_at_point([zero], [1.0] | nbody_system.length, [zero], [zero])
self.assertAlmostEqual(fx, [0.0] | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy, [0.0] | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz, [0.0] | nbody_system.acceleration, 6)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point([zero], [x0], [zero], [zero])
potential1 = instance.get_potential_at_point([zero], [x1], [zero], [zero])
fx0, fy0, fz0 = instance.get_gravity_at_point([zero], [x0], [zero], [zero])
fx1, fy1, fz1 = instance.get_gravity_at_point([zero], [x1], [zero], [zero])
self.assertAlmostEqual(fy0[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz0[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy1[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz1[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0 ** 2) + 1.0 / (x1 ** 2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0[0], 5)
self.assertAlmostEqual(potential0, potential1, 6)
def test5(self):
print("Testing SinkParticles accrete, one particle within two sinks' radii")
particles = Particles(10)
particles.radius = 42.0 | units.RSun
particles.mass = list(range(1,11)) | units.MSun
particles.position = [[i, 2*i, 3*i] for i in range(10)] | units.parsec
particles.velocity = [[i, 0, -i] for i in range(10)] | units.km/units.s
particles.age = list(range(10)) | units.Myr
copy = particles.copy()
sinks = SinkParticles(particles[[3, 7]], sink_radius=[4,12]|units.parsec,looping_over=self.looping_over)
self.assertEqual(sinks.sink_radius, [4.0, 12.0] | units.parsec)
self.assertEqual(sinks.mass, [4.0, 8.0] | units.MSun)
self.assertEqual(sinks.position, [[3, 6, 9], [7, 14, 21]] | units.parsec)
sinks.accrete(particles)
self.assertEqual(len(particles), 4) # 6 particles were accreted
self.assertEqual(sinks.mass, [12.0, 40.0] | units.MSun) # mass of sinks increased
self.assertEqual(sinks.get_intersecting_subset_in(particles).mass,
[12.0, 40.0] | units.MSun) # original particles' masses match
self.assertEqual(particles.total_mass(), copy.total_mass()) # total mass is conserved
self.assertEqual(particles.center_of_mass(), copy.center_of_mass()) # center of mass is conserved
self.assertEqual(particles.center_of_mass_velocity(), copy.center_of_mass_velocity()) # center of mass velocity is conserved
self.assertEqual(particles.total_momentum(), copy.total_momentum()) # momentum is conserved
self.assertEqual(particles.total_angular_momentum()+sinks.angular_momentum.sum(axis=0), copy.total_angular_momentum()) # angular_momentum is conserved
def merge_two_stars(bodies, particles_in_encounter):
"""
Merge two stars into one
"""
com_pos = particles_in_encounter.center_of_mass()
com_vel = particles_in_encounter.center_of_mass_velocity()
star_0 = particles_in_encounter[0]
star_1 = particles_in_encounter[1]
new_particle = Particles(1)
new_particle.birth_age = particles_in_encounter.birth_age.min()
new_particle.mass = particles_in_encounter.total_mass()
new_particle.age = min(particles_in_encounter.age) \
* max(particles_in_encounter.mass)/new_particle.mass
new_particle.position = com_pos
new_particle.velocity = com_vel
new_particle.name = "Star"
new_particle.radius = particles_in_encounter.radius.max()
print("# old radius:", particles_in_encounter.radius.in_(units.AU))
print("# new radius:", new_particle.radius.in_(units.AU))
bodies.add_particles(new_particle)
print("# Two stars (M=", particles_in_encounter.mass.in_(units.MSun),
") collided at d=",
(star_0.position - star_1.position).length().in_(units.AU))
bodies.remove_particles(particles_in_encounter)
def _planets_only(define_mercury_attributes = False):
data = numpy.array([tuple(entry) for entry in _solsysdat], dtype=[('name','S10'),
('mass','<f8'), ('celimit','<f8'), ('density','<f8'),
('x','<f8'), ('y','<f8'), ('z','<f8'),
('vx','<f8'), ('vy','<f8'), ('vz','<f8'),
('Lx','<f8'), ('Ly','<f8'), ('Lz','<f8')])
planets = Particles(len(_solsysdat))
planets.name = list(data['name'])
print planets.name.dtype
planets.mass = units.MSun.new_quantity(data['mass'])
density = (units.g/units.cm**3).new_quantity(data['density'])
planets.radius = ((planets.mass/density) ** (1/3.0)).as_quantity_in(units.km)
for attribute in ['x', 'y', 'z']:
setattr(planets, attribute, units.AU.new_quantity(data[attribute]))
for attribute in ['vx', 'vy', 'vz']:
setattr(planets, attribute, units.AUd.new_quantity(data[attribute]).as_quantity_in(units.km / units.s))
if define_mercury_attributes:
planets.density = density
angular_momentum_unit = units.MSun * units.AU**2/units.day
for attribute in ['Lx', 'Ly', 'Lz']:
setattr(planets, attribute, angular_momentum_unit.new_quantity(data[attribute]).as_quantity_in(units.J * units.s))
planets.celimit = units.none.new_quantity(data['celimit'])
return planets
def test5(self):
print "Testing SinkParticles accrete, one particle within two sinks' radii"
particles = Particles(10)
particles.radius = 42.0 | units.RSun
particles.mass = range(1,11) | units.MSun
particles.position = [[i, 2*i, 3*i] for i in range(10)] | units.parsec
particles.velocity = [[i, 0, -i] for i in range(10)] | units.km/units.s
particles.age = range(10) | units.Myr
copy = particles.copy()
sinks = SinkParticles(particles[[3, 7]], sink_radius=[4,12]|units.parsec,looping_over=self.looping_over)
self.assertEqual(sinks.sink_radius, [4.0, 12.0] | units.parsec)
self.assertEqual(sinks.mass, [4.0, 8.0] | units.MSun)
self.assertEqual(sinks.position, [[3, 6, 9], [7, 14, 21]] | units.parsec)
sinks.accrete(particles)
self.assertEqual(len(particles), 4) # 6 particles were accreted
self.assertEqual(sinks.mass, [12.0, 40.0] | units.MSun) # mass of sinks increased
self.assertEqual(sinks.get_intersecting_subset_in(particles).mass,
[12.0, 40.0] | units.MSun) # original particles' masses match
self.assertEqual(particles.total_mass(), copy.total_mass()) # total mass is conserved
self.assertEqual(particles.center_of_mass(), copy.center_of_mass()) # center of mass is conserved
self.assertEqual(particles.center_of_mass_velocity(), copy.center_of_mass_velocity()) # center of mass velocity is conserved
self.assertEqual(particles.total_momentum(), copy.total_momentum()) # momentum is conserved
self.assertEqual(particles.total_angular_momentum()+sinks.angular_momentum.sum(axis=0), copy.total_angular_momentum()) # angular_momentum is conserved
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def handle_collision(self, primary, secondary):
colliders = primary + secondary
result = Particles(1)
result.mass = colliders.total_mass() * (1 - self.mass_loss)
result.position = colliders.center_of_mass()
result.velocity = colliders.center_of_mass_velocity()
if hasattr(colliders, "radius"):
result.radius = colliders.radius.amax()
return result
def handle_collision(self, primary, secondary):
colliders = primary + secondary
result = Particles(1)
result.mass = colliders.total_mass() * (1 - self.mass_loss)
result.position = colliders.center_of_mass()
result.velocity = colliders.center_of_mass_velocity()
if hasattr(colliders, "radius"):
result.radius = colliders.radius.amax()
return result
def make_planets(central_particle,
masses,
radii,
density=3 | units.g / units.cm**3,
phi=None,
theta=None,
eccentricity=0.0,
kepler=None,
rng=None):
volumes = masses / density
planet_radii = (3.0 * volumes / (4.0 * numpy.pi))**(1.0 / 3.0)
n = len(masses)
planet_particles = Particles(n)
planet_particles.semimajor_axis = radii
if eccentricity is None:
eccentricity = numpy.abs(rng.normal(-0.00001, 0.00001, n))
planet_particles.eccentricity = eccentricity
planet_particles.mass = masses
planet_particles.radius = planet_radii
if phi is None:
phi = numpy.radians(rng.uniform(0.0, 90.0, 1)[0]) #rotate under x
if theta is None:
theta0 = numpy.radians((rng.normal(-90.0, 90.0,
1)[0])) #rotate under y
theta0 = 0
theta_inclination = numpy.radians(rng.normal(0, 1.0, n))
theta_inclination[0] = 0
theta = theta0 + theta_inclination
#psi = numpy.radians(rng.uniform(0, 180, 1))[0] #0 # numpy.radians(90) # numpy.radians(rng.uniform(0, 180, 1))[0]
psi = numpy.radians(rng.uniform(0.0, 180.0, 1))[
0] #0 # numpy.radians(90) # numpy.radians(rng.uniform(0, 180, 1))[0]
com_particle = central_particle.copy()
for x, t in zip(iter(planet_particles), theta):
pos, vel = posvel_from_orbital_elements(com_particle.mass + x.mass,
x.semimajor_axis,
x.eccentricity, kepler, rng)
pos, vel = rotate(pos, vel, 0, 0, psi) # theta and phi in radians
pos, vel = rotate(pos, vel, 0, t, 0) # theta and phi in radians
pos, vel = rotate(pos, vel, phi, 0, 0) # theta and phi in radians
x.position = pos + com_particle.position
x.velocity = vel + com_particle.velocity
if False:
two_body = Particles(particles=[com_particle, x])
print "dp:", (com_particle.position -
two_body.center_of_mass()).as_quantity_in(units.AU)
com_particle.mass = two_body.mass.sum()
com_particle.position = two_body.center_of_mass()
com_particle.velocity = two_body.center_of_mass_velocity()
#planet_particles.position += central_particle.position
#planet_particles.velocity += central_particle.velocity
return planet_particles
def new_particles_with_internal_structure_from_models(self):
def get_internal_structure(set, particle=None):
return self.models[(set.key == particle.key).nonzero()[0]]
result = Particles(len(self.models))
result.add_function_attribute("get_internal_structure", None, get_internal_structure)
result.mass = [model.dmass.sum().as_quantity_in(self.mass_unit) for model in self.models]
result.radius = [model.radius[-1].as_quantity_in(self.radius_unit) for model in self.models]
result.position = (self.original_center_of_mass + self.stars_after_encounter.position).as_quantity_in(self.position_unit)
result.velocity = (self.original_center_of_mass_velocity + self.stars_after_encounter.velocity).as_quantity_in(self.velocity_unit)
return result
def new_particles_with_internal_structure_from_models(self):
def get_internal_structure(set, particle=None):
return self.models[(set.key == particle.key).nonzero()[0]]
result = Particles(len(self.models))
result.add_function_attribute("get_internal_structure", None, get_internal_structure)
result.mass = [model.dmass.sum().as_quantity_in(self.mass_unit) for model in self.models]
result.radius = [model.radius[-1].as_quantity_in(self.radius_unit) for model in self.models]
result.position = (self.original_center_of_mass + self.stars_after_encounter.position).as_quantity_in(self.position_unit)
result.velocity = (self.original_center_of_mass_velocity + self.stars_after_encounter.velocity).as_quantity_in(self.velocity_unit)
return result
def create_particle_grid(self):
particles = Particles(2000)
particles.radius = 1. | units.RSun
particles.mass = 1. | units.MSun
particles.velocity = [1, 0, -1] | units.km/units.s
i = 0
for x in range(-5, 5):
for y in range(-5, 5):
for z in numpy.arange(-5, 5, 0.5):
particles[i].position = [x, y, z] | units.RSun
i += 1
return particles
def create_particle_grid(self):
particles = Particles(2000)
particles.radius = 1. | units.RSun
particles.mass = 1. | units.MSun
particles.velocity = [1, 0, -1] | units.km/units.s
i = 0
for x in range(-5, 5):
for y in range(-5, 5):
for z in numpy.arange(-5, 5, 0.5):
particles[i].position = [x, y, z] | units.RSun
i += 1
return particles
def new_particles():
particles = Particles(3)
particles.mass=[3.,4.,5.] | nbody_system.mass
particles.position = [
[1, 3, 0],
[-2, -1, 0],
[1, -1, 0],
] | nbody_system.length
particles.velocity = [0.,0.,0.] | nbody_system.speed
particles.radius = 0 | nbody_system.length
return particles
def new_particles():
particles = Particles(3)
particles.mass = [3., 4., 5.] | nbody_system.mass
particles.position = [
[1, 3, 0],
[-2, -1, 0],
[1, -1, 0],
] | nbody_system.length
particles.velocity = [0., 0., 0.] | nbody_system.speed
particles.radius = 0 | nbody_system.length
return particles
def test2(self):
print "Testing SinkParticles initialization from existing particles"
original = Particles(3)
self.assertRaises(AttributeError, SinkParticles, original, expected_message=
"You tried to access attribute 'radius' but this attribute is not defined for this set.")
original.radius = 42.0 | units.RSun
original.mass = 10.0 | units.MSun
original.position = [[i, -i, 2*i] for i in range(3)] | units.parsec
sinks = SinkParticles(original)
self.assertEqual(sinks.sink_radius, 42.0 | units.RSun)
self.assertEqual(sinks.mass, 10.0 | units.MSun)
self.assertEqual(sinks.position, [[0,0,0], [1,-1,2], [2,-2,4]] | units.parsec)
self.assertRaises(AttributeError, getattr, sinks, "bogus", expected_message=
"You tried to access attribute 'bogus' but this attribute is not defined for this set.")
def binary_with_planet(m1=1. | units.MSun,
m2=1. | units.MSun,
m_planet=1 | units.MJupiter,
r1=None,
r2=None,
r_planet=None,
ecc_binary=0,
P_binary=20 | units.day,
ecc_planet=0.,
P_planet=1. | units.yr,
pangle_planet=0.,
a_planet=None):
parts = binary(m1, m2, r1, r2, ecc_binary, P_binary)
mu = constants.G * (m1 + m2 + m_planet)
if a_planet is None:
if P_planet is None:
print "provide a_planet or P_planet"
raise Exception
a_planet = (P_planet / (2 * numpy.pi) * mu**0.5)**(2. / 3.)
rmax = a_planet * (1 + ecc_planet)
r0 = rmax
print a_planet
print a_planet.in_(units.AU), r0.in_(units.AU)
h = (a_planet * mu * (1 - ecc_planet**2))**0.5
v0 = h / r0
planet = Particles(1)
planet.mass = m_planet
if r_planet is None:
r_planet = (1. | units.RJupiter) * (m_planet /
(1. | units.MJupiter))**(1. / 3.)
planet.radius = r_planet
planet.x = numpy.cos(pangle_planet) * r0
planet.y = numpy.sin(pangle_planet) * r0
planet.z = 0. * r0
planet.vx = -numpy.sin(pangle_planet) * v0
planet.vy = numpy.cos(pangle_planet) * v0
planet.vz = 0. * v0
parts.add_particles(planet)
parts.move_to_center()
return parts
def handle_collision(self, primary, secondary, stellar_evolution_code=None):
result = Particles(1)
result.mass = self.next_mass.as_quantity_in(self.parameters.mass_unit)
self.next_mass += 1 | units.kg
if not stellar_evolution_code is None:
se_colliders = (primary + secondary).get_intersecting_subset_in(stellar_evolution_code.particles)
result.radius = se_colliders.radius.sum()
def get_internal_structure(set, particle=None):
return dict(mass=result.mass, radius=result.radius)
result.add_function_attribute("get_internal_structure", None, get_internal_structure)
return result
def handle_collision(self, primary, secondary, stellar_evolution_code=None):
result = Particles(1)
result.mass = self.next_mass.as_quantity_in(self.parameters.mass_unit)
self.next_mass += 1 | units.kg
if not stellar_evolution_code is None:
se_colliders = (primary + secondary).get_intersecting_subset_in(stellar_evolution_code.particles)
result.radius = se_colliders.radius.sum()
def internal_structure(set, particle=None):
return dict(mass=result.mass, radius=result.radius)
result.add_function_attribute("internal_structure", None, internal_structure)
return result
def xtest08(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura get_gravity_at_point and get_potential_at_point")
instance = self.new_instance_of_an_optional_code(
Sakura, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
# instance.parameters.smbh_mass = 0.0 | nbody_system.mass
particles = Particles(2)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.0 | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]
] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero,
1.0 | nbody_system.length,
zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1)
fx = (-1.0 / (x0**2) + 1.0 /
(x1**2)) * (1.0
| nbody_system.length**3 / nbody_system.time**2)
self.assertAlmostEqual(fx, fx0)
self.assertAlmostEqual(potential0, potential1)
instance.stop()
def new_initial_system():
n = 10.0
xi = 0.001
result = Particles(3)
mass = numpy.random.rand(3)
mass = mass / mass.sum()
result.mass = mass * (1.0 | nbody_system.mass)
a = (numpy.random.rand() * n) + (n+xi)
b = numpy.random.rand() * 2*n
c = (numpy.random.rand() * 2*n) + xi
result[0].position = [0, 0, 0] | nbody_system.length
result[1].position = [a, 0, 0] | nbody_system.length
result[2].position = [b, c, 0] | nbody_system.length
result.radius = 0 | nbody_system.length
result.velocity = [0, 0, 0] | nbody_system.speed
return result
def new_initial_system():
n = 10.0
xi = 0.001
result = Particles(3)
mass = numpy.random.rand(3)
mass = mass / mass.sum()
result.mass = mass * (1.0 | nbody_system.mass)
a = (numpy.random.rand() * n) + (n + xi)
b = numpy.random.rand() * 2 * n
c = (numpy.random.rand() * 2 * n) + xi
result[0].position = [0, 0, 0] | nbody_system.length
result[1].position = [a, 0, 0] | nbody_system.length
result[2].position = [b, c, 0] | nbody_system.length
result.radius = 0 | nbody_system.length
result.velocity = [0, 0, 0] | nbody_system.speed
return result
def merge_two_stars(bodies, particles_in_encounter):
com_pos = particles_in_encounter.center_of_mass()
com_vel = particles_in_encounter.center_of_mass_velocity()
new_particle=Particles(1)
mu = particles_in_encounter[0].mass/particles_in_encounter.mass.sum()
new_particle.birth_age = particles_in_encounter.birth_age.min()
new_particle.mass = particles_in_encounter.total_mass()
new_particle.position = com_pos
new_particle.velocity = com_vel
new_particle.name = "Star"
new_particle.radius = particles_in_encounter.radius.max()
print "old radius:", particles_in_encounter.radius.value_in(units.AU)
print "new radius:", new_particle.radius.value_in(units.AU)
bodies.add_particles(new_particle)
print "Two stars (M=",particles_in_encounter.mass,") collided at d=", com_pos.length()
bodies.remove_particles(particles_in_encounter)
def test4(self):
print("Testing Brutus evolve_model, 2 particles")
particles = Particles(2)
particles.mass = 0.5 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | units.km / units.s
particles[1].vy = (constants.G * (1.0 | units.MSun) /
(1.0 | units.AU)).sqrt()
particles.move_to_center()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(Brutus, convert_nbody)
instance.initialize_code()
instance.parameters.bs_tolerance = 1e-6
instance.parameters.word_length = 56
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y,
6)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x,
6)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x,
6)
instance.cleanup_code()
instance.stop()
def create_testparticle(position, velocity):
"""
Create number test particles with opposite x velocities starting at
approximately the same point (x0,0).
DEFAULT PARAMETERS:
x0 = 349931 the estimated Earth - Moon Lagrange point
vorbit = lunar orbital velocity
"""
particles = Particles(1)
particles.mass = 0 | units.kg
particles.radius = 0 | units.m
particles.position = position
particles.velocity = velocity
return particles
def merge_two_stars(bodies, particles_in_encounter):
com_pos = particles_in_encounter.center_of_mass()
com_vel = particles_in_encounter.center_of_mass_velocity()
new_particle = Particles(1)
mu = particles_in_encounter[0].mass / particles_in_encounter.mass.sum()
new_particle.birth_age = particles_in_encounter.birth_age.min()
new_particle.mass = particles_in_encounter.total_mass()
new_particle.position = com_pos
new_particle.velocity = com_vel
new_particle.name = "Star"
new_particle.radius = particles_in_encounter.radius.max()
print("old radius:", particles_in_encounter.radius.value_in(units.AU))
print("new radius:", new_particle.radius.value_in(units.AU))
bodies.add_particles(new_particle)
print("Two stars (M=", particles_in_encounter.mass, ") collided at d=",
com_pos.length())
bodies.remove_particles(particles_in_encounter)
def setup_particles_in_nbodycode(self):
staggered_grid_shape = numpy.asarray(self.gridcode.grid.shape) + 2
corner0 = self.gridcode.grid[0][0][0].position
corner1 = self.gridcode.grid[-1][-1][-1].position
delta = self.gridcode.grid[1][1][1].position - corner0
print delta.prod()
self.volume = delta.prod()
staggered_corner0 = corner0 - delta
staggered_corner1 = corner1
self.staggered_grid = Grid.create(
staggered_grid_shape,
staggered_corner1 - staggered_corner0 + delta)
#self.staggered_grid.x += staggered_corner0.x
#self.staggered_grid.y += staggered_corner0.x
#self.staggered_grid.z += staggered_corner0.x
#self.staggered_grid.p000 = 0.0 | mass
#self.staggered_grid.p100 = 0.0 | mass
#self.staggered_grid.p010 = 0.0 | mass
#self.staggered_grid.p110 = 0.0 | mass
#self.staggered_grid.p000 = 0.0 | mass
#self.staggered_grid.p100 = 0.0 | mass
#self.staggered_grid.p011 = 0.0 | mass
#self.staggered_grid.p111 = 0.0 | mass
#self.staggered_grid.p001 = 0.0 | mass
#self.staggered_grid.p101 = 0.0 | mass
self.normal_grid = Grid.create(self.gridcode.grid.shape,
corner1 - corner0 + delta)
particles = Particles(self.normal_grid.size)
particles.mass = 0.0 | mass
particles.x = self.grid.x.flatten()
particles.y = self.grid.y.flatten()
particles.z = self.grid.z.flatten()
particles.vx = 0.0 | speed
particles.vy = 0.0 | speed
particles.vz = 0.0 | speed
particles.radius = 0.0 | length
self.nbodycode.particles.add_particles(particles)
self.from_model_to_nbody = particles.new_channel_to(
self.nbodycode.particles)
self.nbodycode.commit_particles()
self.particles = particles
def test8(self):
print "Testing MI6 get_gravity_at_point and get_potential_at_point"
instance = MI6(**default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.smbh_mass = 0.0 | nbody_system.mass
particles = Particles(2)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.0 | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]
] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero,
1.0 | nbody_system.length,
zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1)
fx = (-1.0 / (x0**2) + 1.0 /
(x1**2)) * (1.0
| nbody_system.length**3 / nbody_system.time**2)
self.assertAlmostEqual(fx, fx0)
self.assertAlmostEqual(potential0, potential1)
instance.stop()
def setup_particles_in_nbodycode(self):
staggered_grid_shape = numpy.asarray(self.gridcode.grid.shape) + 2
corner0 = self.gridcode.grid[0][0][0].position
corner1 = self.gridcode.grid[-1][-1][-1].position
delta = self.gridcode.grid[1][1][1].position - corner0
print delta.prod()
self.volume = delta.prod()
staggered_corner0 = corner0 - delta
staggered_corner1 = corner1
self.staggered_grid = Grid.create(
staggered_grid_shape,
staggered_corner1 - staggered_corner0 + delta)
# self.staggered_grid.x += staggered_corner0.x
# self.staggered_grid.y += staggered_corner0.x
# self.staggered_grid.z += staggered_corner0.x
# self.staggered_grid.p000 = 0.0 | mass
# self.staggered_grid.p100 = 0.0 | mass
# self.staggered_grid.p010 = 0.0 | mass
# self.staggered_grid.p110 = 0.0 | mass
# self.staggered_grid.p000 = 0.0 | mass
# self.staggered_grid.p100 = 0.0 | mass
# self.staggered_grid.p011 = 0.0 | mass
# self.staggered_grid.p111 = 0.0 | mass
# self.staggered_grid.p001 = 0.0 | mass
# self.staggered_grid.p101 = 0.0 | mass
self.normal_grid = Grid.create(
self.gridcode.grid.shape, corner1 - corner0 + delta)
particles = Particles(self.normal_grid.size)
particles.mass = 0.0 | mass
particles.x = self.grid.x.flatten()
particles.y = self.grid.y.flatten()
particles.z = self.grid.z.flatten()
particles.vx = 0.0 | speed
particles.vy = 0.0 | speed
particles.vz = 0.0 | speed
particles.radius = 0.0 | length
self.nbodycode.particles.add_particles(particles)
self.from_model_to_nbody = particles.new_channel_to(
self.nbodycode.particles)
self.nbodycode.commit_particles()
self.particles = particles
def xtest04(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Tupan")
print("Testing Tupan evolve_model, 2 particles orbiting the SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | units.km / units.s
particles[1].vy = ((constants.G * (10001.0 | units.MSun) /
(1.0 | units.AU)).sqrt() +
(constants.G * (10000.0 | units.MSun) /
(1.0 | units.AU)).sqrt())
particles.move_to_center()
print(particles)
instance = self.new_instance_of_an_optional_code(
Tupan, self.default_converter)
instance.initialize_code()
# instance.parameters.include_smbh = True
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001)))
position_at_start = primary.position.x
instance.evolve_model(P_corrected / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y,
3)
instance.evolve_model(P_corrected / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x,
3)
instance.evolve_model(P_corrected)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x,
3)
instance.cleanup_code()
instance.stop()
def box(N, L, rho, u, base_grid=uniform_random_unit_cube):
x, y, z = base_grid(N).make_xyz()
Nresult = len(x)
part = Particles(Nresult)
part.x = L * x
part.y = L * y
part.z = L * z
part.mass = (rho * L**3) / Nresult
vunit = (u.unit)**0.5
part.vx = vunit(numpy.zeros_like(x))
part.vy = vunit(numpy.zeros_like(x))
part.vz = vunit(numpy.zeros_like(x))
part.u = u
part.radius = L / Nresult**(1. / 3.)
return part
def make_planets(central_particle, masses, radii, density = 3 | units.g/units.cm**3, phi=None, theta=None, eccentricity = 0.0, kepler = None, rng = None):
volumes = masses / density
planet_radii = (3.0 * volumes / (4.0 * numpy.pi))**(1.0/3.0)
n = len(masses)
planet_particles = Particles(n)
planet_particles.semimajor_axis = radii
if eccentricity is None:
eccentricity = numpy.abs(rng.normal(-0.00001,0.00001,n))
planet_particles.eccentricity = eccentricity
planet_particles.mass = masses
planet_particles.radius = planet_radii
if phi is None:
phi = numpy.radians(rng.uniform(0.0, 90.0, 1)[0])#rotate under x
if theta is None:
theta0 = numpy.radians((rng.normal(-90.0,90.0,1)[0]))#rotate under y
theta0 = 0
theta_inclination = numpy.radians(rng.normal(0, 1.0, n ))
theta_inclination[0] = 0
theta = theta0 + theta_inclination
#psi = numpy.radians(rng.uniform(0, 180, 1))[0] #0 # numpy.radians(90) # numpy.radians(rng.uniform(0, 180, 1))[0]
psi = numpy.radians(rng.uniform(0.0, 180.0, 1))[0] #0 # numpy.radians(90) # numpy.radians(rng.uniform(0, 180, 1))[0]
com_particle = central_particle.copy()
for x, t in zip(iter(planet_particles), theta):
pos,vel = posvel_from_orbital_elements(com_particle.mass + x.mass, x.semimajor_axis, x.eccentricity, kepler, rng)
pos,vel = rotate(pos, vel, 0, 0, psi) # theta and phi in radians
pos,vel = rotate(pos, vel, 0, t, 0) # theta and phi in radians
pos,vel = rotate(pos, vel, phi, 0, 0) # theta and phi in radians
x.position = pos + com_particle.position
x.velocity = vel + com_particle.velocity
if False:
two_body = Particles(particles=[com_particle, x])
print "dp:", (com_particle.position - two_body.center_of_mass()).as_quantity_in(units.AU)
com_particle.mass = two_body.mass.sum()
com_particle.position = two_body.center_of_mass()
com_particle.velocity = two_body.center_of_mass_velocity()
#planet_particles.position += central_particle.position
#planet_particles.velocity += central_particle.velocity
return planet_particles
def test4(self):
print "Testing MI6 evolve_model, 2 particles orbiting the SMBH"
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | units.km / units.s
particles[1].vy = ((constants.G * (10001.0 | units.MSun) /
(1.0 | units.AU)).sqrt() +
(constants.G * (10000.0 | units.MSun) /
(1.0 | units.AU)).sqrt())
particles.move_to_center()
print particles
instance = MI6(self.default_converter, **default_options)
instance.initialize_code()
instance.parameters.include_smbh = True
instance.parameters.lightspeed = constants.c
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001)))
position_at_start = primary.position.x
instance.evolve_model(P_corrected / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y,
3)
instance.evolve_model(P_corrected / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x,
3)
instance.evolve_model(P_corrected)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x,
3)
instance.cleanup_code()
instance.stop()
def test05(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print("Testing Sakura evolve_model, 2 particles, no SMBH")
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) /
(2.0 | units.AU)).sqrt()
particles.move_to_center()
print(particles)
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = self.new_instance_of_an_optional_code(
Sakura, converter, **default_options)
instance.initialize_code()
# instance.parameters.integrator_method = "asakura"
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y,
3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x,
3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x,
3)
instance.cleanup_code()
instance.stop()
def xtest08(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print "Testing Sakura get_gravity_at_point and get_potential_at_point"
instance = Sakura()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length ** 2
# instance.parameters.smbh_mass = 0.0 | nbody_system.mass
particles = Particles(2)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.0 | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1)
fx = (-1.0 / (x0 ** 2) + 1.0 / (x1 ** 2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0)
self.assertAlmostEqual(potential0, potential1)
instance.stop()
def binary_with_planet(m1=1.|units.MSun, m2=1.| units.MSun, m_planet=1|units.MJupiter,
r1=None, r2=None, r_planet=None, ecc_binary=0, P_binary=20 | units.day,
ecc_planet=0., P_planet=1.| units.yr, pangle_planet=0., a_planet=None):
parts=binary(m1,m2,r1,r2,ecc_binary,P_binary)
mu=constants.G*(m1+m2+m_planet)
if a_planet is None:
if P_planet is None:
print "provide a_planet or P_planet"
raise Exception
a_planet=(P_planet/(2*numpy.pi)*mu**0.5)**(2./3.)
rmax=a_planet*(1+ecc_planet)
r0=rmax
print a_planet
print a_planet.in_(units.AU),r0.in_(units.AU)
h=(a_planet*mu*(1-ecc_planet**2))**0.5
v0=h/r0
planet=Particles(1)
planet.mass=m_planet
if r_planet is None:
r_planet=(1.|units.RJupiter)*(m_planet/(1.|units.MJupiter))**(1./3.)
planet.radius=r_planet
planet.x=numpy.cos(pangle_planet)*r0
planet.y=numpy.sin(pangle_planet)*r0
planet.z=0.*r0
planet.vx=-numpy.sin(pangle_planet)*v0
planet.vy=numpy.cos(pangle_planet)*v0
planet.vz=0.*v0
parts.add_particles(planet)
parts.move_to_center()
return parts
def test8(self):
print "Testing MI6 get_gravity_at_point and get_potential_at_point"
instance = MI6(**default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.smbh_mass = 0.0 | nbody_system.mass
particles = Particles(2)
particles.mass = 1.0 | nbody_system.mass
particles.radius = 0.0 | nbody_system.length
particles.position = [[0.0,0.0,0.0], [2.0,0.0,0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
fx, fy, fz = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero)
self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
fx1, fy1, fz1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration)
self.assertAlmostEqual(fx0, -1.0 * fx1)
fx = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0)
self.assertAlmostEqual(potential0, potential1)
instance.stop()
def xtest04(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print "Testing Sakura evolve_model, 2 particles orbiting the SMBH"
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (10001.0 | units.MSun) / (1.0 | units.AU)).sqrt() + (
constants.G * (10000.0 | units.MSun) / (1.0 | units.AU)
).sqrt()
particles.move_to_center()
print particles
instance = Sakura(self.default_converter)
instance.initialize_code()
# instance.parameters.include_smbh = True
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001)))
position_at_start = primary.position.x
instance.evolve_model(P_corrected / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P_corrected / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P_corrected)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def test4(self):
print "Testing MI6 evolve_model, 2 particles orbiting the SMBH"
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (10001.0 | units.MSun) / (1.0 | units.AU)).sqrt() + (
constants.G * (10000.0 | units.MSun) / (1.0 | units.AU)
).sqrt()
particles.move_to_center()
print particles
instance = MI6(self.default_converter, **default_options)
instance.initialize_code()
instance.parameters.include_smbh = True
instance.parameters.lightspeed = constants.c
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001)))
position_at_start = primary.position.x
instance.evolve_model(P_corrected / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P_corrected / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P_corrected)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def new_solar_system_for_mercury():
"""
Create initial conditions for the symplectic integrator Mercury, describing
the solar system. Returns a tuple consisting of two particle sets. The first
set contains the central particle (sun) and the second contains the planets
and Pluto (the 'orbiters'). The positions and velocities are in heliocentric
coordinates.
Defined attributes sun:
name, mass, radius, j2, j4, j6, Lx, Ly, Lz
Defined attributes orbiters:
name, mass, radius, density, x, y, z, vx, vy, vz, Lx, Ly, Lz, celimit
"""
planets = _planets_only(define_mercury_attributes = True)
centre = Particles(1)
centre.name = 'SUN'
centre.mass = 1.0 | units.MSun
centre.radius = 0.0000001 | units.AU
centre.j2 = .0001|units.AU**2
centre.j4 = .0|units.AU**4
centre.j6 = .0|units.AU**6
centre.angular_momentum = [0.0, 0.0, 0.0] | units.MSun * units.AU**2/units.day
return centre, planets
def test05(self):
if MODULES_MISSING:
self.skip("Failed to import a module required for Sakura")
print "Testing Sakura evolve_model, 2 particles, no SMBH"
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt()
particles.move_to_center()
print particles
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = Sakura(converter)
instance.initialize_code()
# instance.parameters.integrator_method = "asakura"
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3)
instance.cleanup_code()
instance.stop()
def handle_collision(self, primary, secondary):
colliders = primary.as_set().copy()
colliders.add_particle(secondary)
if self.verbose:
print "Handling collision between stars with masses {0}.".format(colliders.mass)
if inspect.isclass(self.collision_code):
collision_code = self.collision_code(**self.collision_code_arguments)
if hasattr(collision_code, "initialize_code"):
collision_code.initialize_code()
for par, value in self.collision_code_parameters.iteritems():
setattr(collision_code.parameters, par, value)
if hasattr(collision_code, "commit_parameters"):
collision_code.commit_parameters()
else:
collision_code = self.collision_code
handle_collision_args = self.options.copy()
if collision_code.stellar_evolution_code_required:
handle_collision_args["stellar_evolution_code"] = self.stellar_evolution_code
if collision_code.gravity_code_required:
handle_collision_args["gravity_code"] = self.gravity_code
merge_products = collision_code.handle_collision(primary, secondary, **handle_collision_args)
if self.verbose:
print "{0} concluded with return value:\n{1}".format(self.collision_code_name, merge_products)
if not self.stellar_evolution_code is None:
if (hasattr(self.stellar_evolution_code, "new_particle_from_model") and
(hasattr(merge_products, "internal_structure"))):
for merge_product in merge_products:
self.stellar_evolution_code.new_particle_from_model(
merge_product.internal_structure(),
0.0 | units.Myr,
key = merge_product.key
)
else:
self.stellar_evolution_code.particles.add_particles(merge_products)
self.stellar_evolution_code.particles.remove_particles(colliders)
if self.verbose:
print "Colliders have been replaced by merge product in {0}.".format(self.stellar_evolution_code.__class__.__name__)
if inspect.isclass(self.collision_code):
merge_products = merge_products.copy()
if hasattr(collision_code, "stop"):
collision_code.stop()
if not self.gravity_code is None:
new_grav_particles = Particles(keys=merge_products.key)
new_grav_particles.mass = merge_products.mass
if hasattr(merge_products, "radius"):
new_grav_particles.radius = merge_products.radius
elif hasattr(colliders, "radius"):
new_grav_particles.radius = max(colliders.radius)
if hasattr(merge_products, "x"):
new_grav_particles.position = merge_products.position
else:
new_grav_particles.position = colliders.center_of_mass()
if hasattr(merge_products, "vx"):
new_grav_particles.velocity = merge_products.velocity
else:
new_grav_particles.velocity = colliders.center_of_mass_velocity()
self.gravity_code.particles.add_particle(new_grav_particles)
self.gravity_code.particles.remove_particles(colliders)
if self.verbose:
print "Colliders have been replaced by merge product in {0}.".format(self.gravity_code.__class__.__name__)
return merge_products
def get_planetesimals_disk(n_disk, r_in=20.0|units.AU, r_out=50.0|units.AU, m_star=1.0|units.MSun,
alpha=None, m_disk=1.0e-15|units.MSun, seed = 42, disk_num = 1):
"""
returns particles of planetesimal disk with given parameters
"""
numpy.random.seed(seed) # Mess with random seed
for i in xrange(int(disk_num) + 4):
planetesimals = Particles(n_disk)
print "Seed:", seed
print planetesimals.key[:10]
planetesimals.mass = 0.0|units.MJupiter
planetesimals.radius = 100.0|units.km
planetesimals.collection_attributes.timestamp = 0.0 | units.yr
if alpha is not None:
converter = nbody_system.nbody_to_si(m_disk, r_in)
power_disk = ProtoPlanetaryDisk(n_disk, convert_nbody=converter, densitypower=alpha,
Rmin=1.0, Rmax=1.0*r_out/r_in, q_out=0.0, discfraction=1.0).result
x = power_disk.x
y = power_disk.y
z = power_disk.z # <--- Mystery error?
print "X"
print x.value_in(units.AU)
print "Y"
print y.value_in(units.AU)
print "Z"
print z.value_in(units.AU)
#z = 0
print "MASS"
print power_disk.mass
#power_disk.mass = 0.0 * power_disk.mass ###### THIS WORKS!!!! (if you want to switch to this later)
print power_disk.mass
a = (x**2 + y**2)**0.5
print "SM-AXIS"
print a.value_in(units.AU)
phi = numpy.arctan2(y.value_in(units.AU), x.value_in(units.AU))
vc = (constants.G*m_star/a)**0.5
vx = - vc * numpy.sin(phi)
vy = vc * numpy.cos(phi)
vz = 0.0 * vc
# vz = - vc * numpy.sin(phi) # ???????????????????????????????????????????????????????????????? #
print "VX"
print vx.value_in(units.km / units.s)
print "VY"
print vy.value_in(units.km / units.s)
print "VZ"
print vz.value_in(units.km / units.s)
print "PLANAR VELOCITY VECTOR"
print ((vx**2 + vy**2)**(0.5)).value_in(units.km / units.s)
#vx = power_disk.vx
#vy = power_disk.vy
#vz = power_disk.vz
#print "POWER DISK VX"
#print vx.value_in(units.km / units.s)
#print "POWER DISK VY"
#print vy.value_in(units.km / units.s)
#print "POWER DISK VZ"
#print vz.value_in(units.km / units.s)
else:
a = r_in + (r_out-r_in)*numpy.random.rand(n_disk)
phi_rand = 2.0 * numpy.pi * numpy.random.rand(n_disk)
x = a * numpy.cos(phi_rand)
y = a * numpy.sin(phi_rand)
z = 0.0 * a
vc = (constants.G*m_star/a)**0.5
vx = - vc * numpy.sin(phi_rand)
vy = vc * numpy.cos(phi_rand)
vz = 0.0 * vc
planetesimals.x = x
planetesimals.y = y
planetesimals.z = z
planetesimals.vx = vx
planetesimals.vy = vy
planetesimals.vz = vz
return planetesimals
