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