def test23(self): particles = datamodel.Particles(2) particles.x = [0.0, 10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.vx = 1.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 0.1 | nbody_system.mass instance = BHTree(redirection="none") instance.particles.add_particles(particles) instance.commit_particles() instance.evolve_model(0.1 | nbody_system.time) self.assertFalse(instance.particles[0].vy > 0 | nbody_system.speed) self.assertAlmostRelativeEquals(instance.particles[0].x, 0.1 | nbody_system.length, 4) instance.particles.new_channel_to(particles).copy() particles.vy = 1 | nbody_system.speed particles.new_channel_to(instance.particles).copy() instance.evolve_model(0.2 | nbody_system.time) self.assertTrue(instance.particles[0].vy > 0 | nbody_system.speed) self.assertAlmostRelativeEquals(instance.particles[0].y, 0.1 | nbody_system.length, 4) instance.stop()
def test11(self): convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m) instance = BHTree(convert_nbody) particles = datamodel.Particles(2) self.assertEquals(len(instance.particles), 0) particles.mass = [15.0, 30.0] | units.kg particles.radius = [10.0, 20.0] | units.m particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0] ] | units.m / units.s instance.particles.add_particles(particles) copyof = instance.particles.copy() self.assertAlmostEqual(30 | units.kg, copyof[1].mass, 6) copyof[1].mass = 35 | units.kg copyof.copy_values_of_all_attributes_to(instance.particles) self.assertAlmostEqual(35 | units.kg, instance.particles[1].mass, 6) instance.stop()
def new_gas_code_bhtree(self): result = BHTree(self.converter) result.parameters.epsilon_squared = self.gas_epsilon ** 2 result.parameters.timestep = 0.125 * self.interaction_timestep result.particles.add_particles(self.new_particles_cluster_as_gas()) result.commit_particles() return result
def test1(self): print "Test collect_required_attributes" in_memory = self.new_colliders() gravity = BHTree(nbody_system.nbody_to_si(1|units.MSun, 1.0|units.RSun)) gravity.particles.add_particles(in_memory) stellar = SeBa() stellar.particles.add_particles(in_memory) collision = StellarEncounterInHydrodynamics(None, None, verbose=True) self.assertFalse(hasattr(in_memory, "radius")) collision.collect_required_attributes(in_memory, gravity, stellar) self.assertTrue(hasattr(in_memory, "radius")) self.assertAlmostRelativeEqual(in_memory.radius.sum(), 4.2458 | units.RSun, 3) from_stellar = stellar.particles.copy() for attribute in ["x", "y", "z", "vx", "vy", "vz"]: self.assertFalse(hasattr(from_stellar, attribute)) collision.collect_required_attributes(from_stellar, gravity, stellar) gravity.stop() stellar.stop() for attribute in ["x", "y", "z", "vx", "vy", "vz"]: self.assertTrue(hasattr(from_stellar, attribute)) self.assertAlmostEqual(from_stellar.position, in_memory.position) self.assertAlmostEqual(from_stellar.velocity, in_memory.velocity)
def test1(self): print("Test collect_required_attributes") in_memory = self.new_colliders() gravity = BHTree(nbody_system.nbody_to_si(1|units.MSun, 1.0|units.RSun)) gravity.particles.add_particles(in_memory) stellar = SeBa() stellar.particles.add_particles(in_memory) collision = StellarEncounterInHydrodynamics(None, None, verbose=True) self.assertFalse(hasattr(in_memory, "radius")) collision.collect_required_attributes(in_memory, gravity, stellar) self.assertTrue(hasattr(in_memory, "radius")) self.assertAlmostRelativeEqual(in_memory.radius.sum(), 4.2458 | units.RSun, 3) from_stellar = stellar.particles.copy() for attribute in ["x", "y", "z", "vx", "vy", "vz"]: self.assertFalse(hasattr(from_stellar, attribute)) collision.collect_required_attributes(from_stellar, gravity, stellar) gravity.stop() stellar.stop() for attribute in ["x", "y", "z", "vx", "vy", "vz"]: self.assertTrue(hasattr(from_stellar, attribute)) self.assertAlmostEqual(from_stellar.position, in_memory.position) self.assertAlmostEqual(from_stellar.velocity, in_memory.velocity)
def new_star_code_bhtree(self): result = BHTree() result.parameters.epsilon_squared = self.star_epsilon**2 result.parameters.timestep = 0.125 * self.interaction_timestep result.particles.add_particles(self.new_particles_cluster()) result.commit_particles() return result
def test22(self): particles = datamodel.Particles(2) particles.x = [0.0,10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass instance = BHTree() instance.particles.add_particles(particles) instance.commit_particles() self.assertEquals(instance.particles[0].radius, 0.0 | nbody_system.length) p = datamodel.Particle( x = 1.0 | nbody_system.length, y = 2.0 | nbody_system.length, z = 3.0 | nbody_system.length, vx = 1.0 | nbody_system.speed, vy = 2.0 | nbody_system.speed, vz = 3.0 | nbody_system.speed, mass = 1.0 | nbody_system.mass, radius = 4.0 | nbody_system.length, ) instance.particles.add_particle(p) self.assertEquals(instance.particles[0].radius, 0.0 | nbody_system.length) self.assertEquals(instance.particles[1].radius, 0.0 | nbody_system.length) self.assertEquals(instance.particles[2].radius, 4.0 | nbody_system.length) instance.stop()
def setup_codes(stars_below_cut, stars_above_cut, nbody_converter): if len(stars_below_cut) is 0: # direct print "There are zero stars below the cut-off, using direct solver!" gravity = Hermite(nbody_converter, number_of_workers=4) gravity.particles.add_particles(stars_above_cut) channels = Channels() channels.add_channel(gravity.particles.new_channel_to(stars_above_cut)) return gravity, channels # NB no bridge needed if len(stars_above_cut) is 0: # tree print "There are zero stars above the cut-off, using tree solver!" gravity = BHTree(nbody_converter) gravity.particles.add_particles(stars_below_cut) channels = Channels() channels.add_channel(gravity.particles.new_channel_to(stars_below_cut)) return gravity, channels # NB no bridge needed gravity_low_mass = BHTree(nbody_converter) gravity_low_mass.particles.add_particles(stars_below_cut) gravity_high_mass = Hermite(nbody_converter, number_of_workers=4) gravity_high_mass.particles.add_particles(stars_above_cut) bridge = Bridge(timestep=0.01|units.Myr, use_threading=False) bridge.add_system(gravity_low_mass, (gravity_high_mass,)) bridge.add_system(gravity_high_mass, (gravity_low_mass,)) channels = Channels() channels.add_channel(gravity_low_mass.particles.new_channel_to(stars_below_cut)) channels.add_channel(gravity_high_mass.particles.new_channel_to(stars_above_cut)) return bridge, channels
def test16(self): numpy.random.seed(0) number_of_stars = 2 stars = plummer.new_plummer_model(number_of_stars) stars.radius = 0.00001 | nbody_system.length stars.scale_to_standard() instance = BHTree() instance.initialize_code() instance.parameters.epsilon_squared = (1.0 / 20.0 / (number_of_stars**0.33333) | nbody_system.length)**2 instance.parameters.timestep = 0.004 | nbody_system.time instance.parameters.timestep = 0.00001 | nbody_system.time instance.commit_parameters() print instance.parameters.timestep instance.particles.add_particles(stars) instance.commit_particles() energy_total_t0 = instance.potential_energy + instance.kinetic_energy request = instance.evolve_model. async (1.0 | nbody_system.time) request.result() energy_total_t1 = instance.potential_energy + instance.kinetic_energy self.assertAlmostRelativeEqual(energy_total_t0, energy_total_t1, 3) instance.stop() numpy.random.seed()
def test11(self): convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m) instance = BHTree(convert_nbody) particles = datamodel.Particles(2) self.assertEquals(len(instance.particles), 0) particles.mass = [15.0, 30.0] | units.kg particles.radius = [10.0, 20.0] | units.m particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s instance.particles.add_particles(particles) copyof = instance.particles.copy() self.assertAlmostEqual(30 | units.kg, copyof[1].mass, 6) copyof[1].mass = 35 | units.kg copyof.copy_values_of_all_attributes_to(instance.particles) self.assertAlmostEqual(35 | units.kg, instance.particles[1].mass, 6) instance.stop()
def evolve_cluster_in_galaxy(N, W0, Rinit, tend, timestep, M, R): R_galaxy = 0.1 | units.kpc M_galaxy = 1.6e10 | units.MSun converter = nbody_system.nbody_to_si(M_galaxy, R_galaxy) galaxy = new_plummer_model(10000, convert_nbody=converter) print "com:", galaxy.center_of_mass().in_(units.kpc) print "comv:", galaxy.center_of_mass_velocity().in_(units.kms) print len(galaxy) galaxy_code = BHTree(converter, number_of_workers=2) galaxy_code.parameters.epsilon_squared = (0.01 | units.kpc)**2 channe_to_galaxy = galaxy_code.particles.new_channel_to(galaxy) channe_to_galaxy.copy() galaxy_code.particles.add_particles(galaxy) inner_stars = galaxy.select(lambda r: r.length() < Rinit, ["position"]) Minner = inner_stars.mass.sum() print "Minner=", Minner.in_(units.MSun) print "Ninner=", len(inner_stars) vc_inner = (constants.G * Minner / Rinit).sqrt() converter = nbody_system.nbody_to_si(Mcluster, Rcluster) stars = new_king_model(N, W0, convert_nbody=converter) masses = new_powerlaw_mass_distribution(N, 0.1 | units.MSun, 100 | units.MSun, -2.35) stars.mass = masses stars.scale_to_standard(converter) stars.x += Rinit stars.vy += 0.8 * vc_inner cluster_code = ph4(converter, number_of_workers=2) cluster_code.particles.add_particles(stars) channel_to_stars = cluster_code.particles.new_channel_to(stars) system = bridge(verbose=False) system.add_system(cluster_code, (galaxy_code, )) system.add_system(galaxy_code, (cluster_code, )) system.timestep = 0.1 * timestep times = quantities.arange(0 | units.Myr, tend, timestep) for i, t in enumerate(times): print "Time=", t.in_(units.Myr) channe_to_galaxy.copy() channel_to_stars.copy() inner_stars = galaxy.select(lambda r: r.length() < Rinit, ["position"]) print "Minner=", inner_stars.mass.sum().in_(units.MSun) system.evolve_model(t, timestep=timestep) plot_galaxy_and_stars(galaxy, stars) galaxy_code.stop() cluster_code.stop()
def test14(self): print "Test14: Testing BHTree parameters (I)" convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU) instance = BHTree(convert_nbody) value,error = instance.legacy_interface.get_epsilon_squared() self.assertEquals(0, error) self.assertEquals(0.125, value) self.assertAlmostEquals(0.125 | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2) for x in [0.01, 0.1, 0.2]: instance.parameters.epsilon_squared = x | units.AU**2 self.assertAlmostEquals(x | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2) (value, error) = instance.legacy_interface.get_time_step() self.assertEquals(0, error) self.assertEquals(0.015625, value) self.assertAlmostEquals(0.015625 | units.yr, instance.parameters.timestep, in_units=units.yr) for x in [0.001, 0.01, 0.1]: instance.parameters.timestep = x | units.yr self.assertAlmostEquals(x | units.yr, instance.parameters.timestep, in_units=units.yr) (value, error) = instance.legacy_interface.get_theta_for_tree() self.assertEquals(0, error) self.assertEquals(0.75, value) self.assertEquals(0.75, instance.parameters.opening_angle) for x in [0.2, 0.5, 0.7]: instance.parameters.opening_angle = x self.assertEquals(x, instance.parameters.opening_angle) (value, error) = instance.legacy_interface.get_use_self_gravity() self.assertEquals(0, error) self.assertEquals(1, value) self.assertEquals(1, instance.parameters.use_self_gravity) for x in [0, 1]: instance.parameters.use_self_gravity = x self.assertEquals(x, instance.parameters.use_self_gravity) (value, error) = instance.legacy_interface.get_ncrit_for_tree() self.assertEquals(0, error) self.assertEquals(12, value) self.assertEquals(12, instance.parameters.ncrit_for_tree) for x in [512, 2048, 4096]: instance.parameters.ncrit_for_tree = x self.assertEquals(x, instance.parameters.ncrit_for_tree) (value, error) = instance.legacy_interface.get_dt_dia() self.assertEquals(0, error) self.assertEquals(1.0, value) self.assertAlmostEquals(1.0 | units.yr, instance.parameters.dt_dia, in_units=units.yr) for x in [0.1, 10.0, 100.0]: instance.parameters.dt_dia = x | units.yr self.assertAlmostEquals(x | units.yr, instance.parameters.dt_dia, in_units=units.yr) instance.stop()
def evolve_cluster(cluster,mCut,dt,tend,mCluster,rCluster,dump=False,dump_dir='data_dump'): if dump: print('Will be saving data in:'+dump_dir) converter=nbody_system.nbody_to_si(mCluster,rCluster) # Splitting particle according to mass_cut low_mass_stars = cluster.select(lambda m: m < mCut,["mass"]) high_mass_stars = cluster.select(lambda m: m >= mCut,["mass"]) # Sanity checks print('Number of low-mass stars:',low_mass_stars.__len__()) print('Number of high-mass stars:',high_mass_stars.__len__()) # Making models and assigning particles code_tree = BHTree(converter) code_direct = ph4(converter) code_tree.particles.add_particles(low_mass_stars) code_direct.particles.add_particles(high_mass_stars) channel_from_code_tree = code_tree.particles.new_channel_to(low_mass_stars) channel_from_code_direct = code_direct.particles.new_channel_to(high_mass_stars) # Making bridge combined_gravity = bridge() combined_gravity.add_system(code_tree,(code_direct,)) combined_gravity.add_system(code_direct,(code_tree,)) combined_gravity.timestep = dt # Making first snapshot #plot_cluster(low_mass_stars,high_mass_stars,'t=0',save=True) # Evolving the model times = quantities.arange(0|units.Myr, tend, dt) mCut_str = str(mCut.value_in(units.MSun)) for i,t in enumerate(times): print "Time=", t.in_(units.Myr) channel_from_code_tree.copy() channel_from_code_direct.copy() combined_gravity.evolve_model(t, timestep=dt) snapshot_name = 't_'+str(t.in_(units.Myr)) plot_cluster(low_mass_stars,high_mass_stars,snapshot_name,save=True) time = str(t.value_in(units.Myr)) if dump: pkl.dump(low_mass_stars, open(dump_dir+'/t'+time+'_m'+mCut_str+'_low_mass.p', 'wb')) pkl.dump(high_mass_stars, open(dump_dir+'/t'+time+'_m'+mCut_str+'_high_mass.p', 'wb')) code_tree.stop() code_direct.stop()
def test17(self): print "Testing BHTree collision_detection" particles = datamodel.Particles(7) particles.mass = 0.001 | 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 = BHTree(redirection='none') instance.initialize_code() instance.parameters.set_defaults() # Uncommenting any of the following two lines will suppress collision detection #~ instance.parameters.use_self_gravity = 0 #~ instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2 instance.parameters.opening_angle = 0.1 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 = datamodel.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 evolve_cluster(cluster,mCut,dt,tend,mCluster,rCluster): converter=nbody_system.nbody_to_si(mCluster,rCluster) # Splitting particle according to mass_cut low_mass_stars = cluster.select(lambda m: m < mCut,["mass"]) high_mass_stars = cluster.select(lambda m: m >= mCut,["mass"]) # Sanity checks print('dynamical timescale:', cluster.dynamical_timescale().value_in(units.Myr)) print('Number of low-mass stars:',low_mass_stars.__len__()) print('Number of high-mass stars:',high_mass_stars.__len__()) #plot_cluster(low_mass_stars, high_mass_stars) # Making models and assigning particles code_tree = BHTree(converter) code_direct = ph4(converter) code_tree.particles.add_particles(low_mass_stars) code_direct.particles.add_particles(high_mass_stars) channel_from_code_tree = code_tree.particles.new_channel_to(low_mass_stars) channel_from_code_direct = code_direct.particles.new_channel_to(high_mass_stars) # Making bridge combined_gravity = bridge() combined_gravity.add_system(code_tree,(code_direct,)) combined_gravity.add_system(code_direct,(code_tree,)) combined_gravity.timestep = dt # Evolving the model time_series = [] half_mass_radii = [] core_radii = [] times = quantities.arange(0.|units.Myr, tend, dt) for i,t in enumerate(times): print "Time =", t.in_(units.Myr) channel_from_code_tree.copy() channel_from_code_direct.copy() time_series.append(t.value_in(units.Myr)) pos,coreradius,coredens=cluster.densitycentre_coreradius_coredens(converter) lr,mf=cluster.LagrangianRadii(converter) # outputs are radii, mass fractions half_mass_radii.append(lr[5].value_in(units.parsec)) # 5th argument attributes to half-mass radius core_radii.append(coreradius.value_in(units.parsec)) combined_gravity.evolve_model(t, timestep=dt) code_tree.stop() code_direct.stop() # Plotting results #plot_cluster(low_mass_stars, high_mass_stars) # Plotting radii plot_radii(time_series, half_mass_radii, x_label='time(Myr)', y_label='half-mass radius (pc)') plot_radii(time_series, core_radii, x_label='time(Myr)', y_label='core radius (pc)')
def evolve_cluster_in_galaxy(N, W0, Rinit, tend, timestep, M, R): R_galaxy=0.1 | units.kpc M_galaxy=1.6e10 | units.MSun converter=nbody_system.nbody_to_si(M_galaxy, R_galaxy) galaxy=new_plummer_model(10000,convert_nbody=converter) print "com:", galaxy.center_of_mass().in_(units.kpc) print "comv:", galaxy.center_of_mass_velocity().in_(units.kms) print len(galaxy) galaxy_code = BHTree(converter, number_of_workers=2) galaxy_code.parameters.epsilon_squared = (0.01 | units.kpc)**2 channe_to_galaxy = galaxy_code.particles.new_channel_to(galaxy) channe_to_galaxy.copy() galaxy_code.particles.add_particles(galaxy) inner_stars = galaxy.select(lambda r: r.length()<Rinit,["position"]) Minner = inner_stars.mass.sum() print "Minner=", Minner.in_(units.MSun) print "Ninner=", len(inner_stars) vc_inner = (constants.G*Minner/Rinit).sqrt() converter=nbody_system.nbody_to_si(Mcluster,Rcluster) stars=new_king_model(N,W0,convert_nbody=converter) masses = new_powerlaw_mass_distribution(N, 0.1|units.MSun, 100|units.MSun, -2.35) stars.mass = masses stars.scale_to_standard(converter) stars.x += Rinit stars.vy += 0.8*vc_inner cluster_code=ph4(converter, number_of_workers=2) cluster_code.particles.add_particles(stars) channel_to_stars=cluster_code.particles.new_channel_to(stars) system=bridge(verbose=False) system.add_system(cluster_code, (galaxy_code,)) system.add_system(galaxy_code, (cluster_code,)) system.timestep = 0.1*timestep times = quantities.arange(0|units.Myr, tend, timestep) for i,t in enumerate(times): print "Time=", t.in_(units.Myr) channe_to_galaxy.copy() channel_to_stars.copy() inner_stars = galaxy.select(lambda r: r.length()<Rinit,["position"]) print "Minner=", inner_stars.mass.sum().in_(units.MSun) system.evolve_model(t,timestep=timestep) plot_galaxy_and_stars(galaxy, stars) galaxy_code.stop() cluster_code.stop()
def test20(self): particles = datamodel.Particles(2) particles.x = [0.0, 10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass very_short_time_to_evolve = 1 | units.s very_long_time_to_evolve = 1e9 | nbody_system.time instance = BHTree() instance.initialize_code() instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve self.assertEquals(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve) instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2 instance.particles.add_particles(particles) codeparticles1 = instance.particles instance.particles.add_particle( datamodel.Particle(position=[0, 1, 2] | nbody_system.length, velocity=[0, 0, 0] | nbody_system.speed, radius=0.005 | nbody_system.length, mass=1 | nbody_system.mass)) codeparticles2 = instance.particles self.assertTrue(codeparticles1 is codeparticles2) instance.cleanup_code() codeparticles3 = instance.particles self.assertFalse(codeparticles1 is codeparticles3) instance.stop()
def test19(self): particles = datamodel.Particles(2) particles.x = [0.0, 10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass very_short_time_to_evolve = 1 | units.s very_long_time_to_evolve = 1e9 | nbody_system.time instance = BHTree() instance.initialize_code() instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve self.assertEquals(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve) instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2 instance.particles.add_particles(particles) instance.stopping_conditions.timeout_detection.enable() start = time.time() instance.evolve_model(very_long_time_to_evolve) end = time.time() self.assertTrue( instance.stopping_conditions.timeout_detection.is_set()) self.assertTrue( (end - start) < very_short_time_to_evolve.value_in(units.s) + 2) #2 = some overhead compensation instance.stop()
def test13(self): convert_nbody = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.m) instance = BHTree(convert_nbody) instance.commit_parameters() particles = datamodel.Particles(2) self.assertEquals(len(instance.particles), 0) particles.mass = [30.0, 30.0] | units.kg particles.radius = [1.0, 1.0] | units.m particles.position = [[-10.0, 0.0, 0.0], [10.0, 0.0, 0.0]] | units.m particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0] ] | units.m / units.s instance.particles.add_particles(particles) instance.commit_particles() copyof = instance.particles.copy() com = instance.center_of_mass_position self.assertAlmostEqual(com[0], quantities.new_quantity(0.0, units.m), constants.precision) instance.stop()
def test19(self): particles = datamodel.Particles(2) particles.x = [0.0,10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass very_short_time_to_evolve = 1 | units.s very_long_time_to_evolve = 1e9 | nbody_system.time instance = BHTree() instance.initialize_code() instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve self.assertEquals(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve) instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2 instance.particles.add_particles(particles) instance.stopping_conditions.timeout_detection.enable() start = time.time() instance.evolve_model(very_long_time_to_evolve) end = time.time() self.assertTrue(instance.stopping_conditions.timeout_detection.is_set()) self.assertTrue((end-start) < very_short_time_to_evolve.value_in(units.s) + 2)#2 = some overhead compensation instance.stop()
def test20(self): particles = datamodel.Particles(2) particles.x = [0.0,10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass very_short_time_to_evolve = 1 | units.s very_long_time_to_evolve = 1e9 | nbody_system.time instance = BHTree() instance.initialize_code() instance.parameters.stopping_conditions_timeout = very_short_time_to_evolve self.assertEquals(instance.parameters.stopping_conditions_timeout, very_short_time_to_evolve) instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2 instance.particles.add_particles(particles) codeparticles1 = instance.particles instance.particles.add_particle(datamodel.Particle( position = [0,1,2] | nbody_system.length, velocity = [0,0,0] | nbody_system.speed, radius = 0.005 | nbody_system.length, mass = 1 | nbody_system.mass )) codeparticles2 = instance.particles self.assertTrue(codeparticles1 is codeparticles2) instance.cleanup_code() codeparticles3 = instance.particles self.assertFalse(codeparticles1 is codeparticles3) instance.stop()
def test15(self): print "Test15: Testing effect of BHTree parameter epsilon_squared" convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) particles = datamodel.Particles(2) sun = particles[0] sun.mass = 1.0 | units.MSun sun.position = [0.0, 0.0, 0.0] | units.AU sun.velocity = [0.0, 0.0, 0.0] | units.AU / units.yr sun.radius = 1.0 | units.RSun earth = particles[1] earth.mass = 5.9736e24 | units.kg earth.radius = 6371.0 | units.km earth.position = [0.0, 1.0, 0.0] | units.AU earth.velocity = [2.0 * numpy.pi, -0.0001, 0.0] | units.AU / units.yr initial_direction = math.atan((earth.velocity[0] / earth.velocity[1])) final_direction = [] for log_eps2 in range(-9, 10, 2): instance = BHTree(convert_nbody) instance.initialize_code() instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU**2 instance.particles.add_particles(particles) instance.commit_particles() instance.evolve_model(0.25 | units.yr) final_direction.append( math.atan((instance.particles[1].velocity[0] / instance.particles[1].velocity[1]))) instance.stop() # Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees self.assertAlmostEquals(abs(final_direction[0]), abs(initial_direction + math.pi / 2.0), 2) # Large values of epsilon_squared should result in ~ no interaction self.assertAlmostEquals(final_direction[-1], initial_direction, 2) # Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2 delta = [ abs(final_direction[i + 1] - final_direction[i]) for i in range(len(final_direction) - 1) ] self.assertEquals(delta[len(final_direction) // 2 - 1], max(delta))
def nbody_integrator(Ncl, mcl, rcl, t_end, n_steps, escape_velocity_fraction, R): converter = nbody_system.nbody_to_si(mcl, rcl) bodies = new_plummer_model(Ncl, convert_nbody=converter) #estimate of milky way mass by "Mass models of the Milky Way", McMillan blackhole_mass = 1.26e12 | units.MSun blackhole = Particle(mass=blackhole_mass) blackhole.position = [0,0,0] | units.m cluster_velocity = [0,0,0] | units.m / units.s cluster_position = [0,0,0] | units.parsec cluster_position[0] = R G_si = converter.to_si(nbody_system.G) escape_v = (2*G_si*blackhole_mass/R).sqrt().as_quantity_in(units.m/units.s) V = escape_v * escape_velocity_fraction cluster_velocity[1] = V bodies.move_to_center() bodies.velocity += cluster_velocity bodies.position += cluster_position bodies.add_particle(blackhole) gravity = BHTree(converter) gravity.particles.add_particles(bodies) channel_from_gravity_to_framework = gravity.particles.\ new_channel_to(bodies) time = zero dt = t_end / float(n_steps) x = 0 base_path = "encounter_plots/"+str(R.value_in(units.parsec))+"_"+\ str(escape_velocity_fraction)+"_" while time < t_end: plot_cluster(bodies, base_path+str(x),time, rcl, V) time += dt gravity.evolve_model(time) channel_from_gravity_to_framework.copy() x+=1 plot_cluster(bodies, base_path+str(x),time, rcl, V) gravity.stop() return V, bodies
def sub_worker(parts): mode=system_type(parts) if mode=="twobody": #code=TwoBody(conv_sub) code=ph4(conv_sub) elif mode=="solarsystem": #code=Mercury(conv_sub) code=Huayno(conv_sub) elif mode=="nbody": code=BHTree(conv_sub) #code.parameters.inttype_parameter=code.inttypes.SHARED4 return code
def test22(self): particles = datamodel.Particles(2) particles.x = [0.0, 10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass instance = BHTree() instance.particles.add_particles(particles) instance.commit_particles() self.assertEquals(instance.particles[0].radius, 0.0 | nbody_system.length) p = datamodel.Particle( x=1.0 | nbody_system.length, y=2.0 | nbody_system.length, z=3.0 | nbody_system.length, vx=1.0 | nbody_system.speed, vy=2.0 | nbody_system.speed, vz=3.0 | nbody_system.speed, mass=1.0 | nbody_system.mass, radius=4.0 | nbody_system.length, ) instance.particles.add_particle(p) self.assertEquals(instance.particles[0].radius, 0.0 | nbody_system.length) self.assertEquals(instance.particles[1].radius, 0.0 | nbody_system.length) self.assertEquals(instance.particles[2].radius, 4.0 | nbody_system.length) instance.stop()
def parent_worker(): Mgalaxy, Rgalaxy = float( 6.8e10 ) | units.MSun, 2.6 | units.kpc #disk mass for MWPotential2014, Bovy(2015) converter_parent = nbody_system.nbody_to_si(Mgalaxy, Rgalaxy) code = BHTree(converter_parent) #done in src_nemesis #code.parameters.epsilon_squared=0.| units.kpc**2 #code.parameters.end_time_accuracy_factor=0. #code.parameters.dt_param=0.1 return code
def test9(self): instance = BHTree() instance.initialize_code() instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2 particles = datamodel.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.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, 3) self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 3) self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 3) 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, 3) self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration, 3) self.assertAlmostEqual(fy1, 0.0 | nbody_system.acceleration, 3) self.assertAlmostEqual(fz1, 0.0 | nbody_system.acceleration, 3) 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, 2) self.assertAlmostEqual(potential0, potential1, 5) instance.cleanup_code() instance.stop()
def test8(self): convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m) instance = BHTree(convert_nbody) instance.commit_parameters() particles = datamodel.Particles(2) self.assertEquals(len(instance.particles), 0) particles.mass = [15.0, 30.0] | units.kg particles.radius = [10.0, 20.0] | units.m particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s instance.particles.add_particles(particles) instance.commit_particles() instance.particles.mass = [17.0, 33.0] | units.kg self.assertEquals(instance.get_mass(1), 17.0| units.kg) instance.cleanup_code() instance.stop()
def setup_codes(stars_below_cut, stars_above_cut, nbody_converter): gravity_low_mass = BHTree(nbody_converter) gravity_low_mass.particles.add_particles(stars_below_cut) gravity_high_mass = Hermite(nbody_converter) gravity_high_mass.particles.add_particles(stars_above_cut) bridge = Bridge(timestep=0.01|units.Myr, use_threading=False) bridge.add_system(gravity_low_mass, (gravity_high_mass,)) bridge.add_system(gravity_high_mass, (gravity_low_mass,)) channels = Channels() channels.add_channel(gravity_low_mass.particles.new_channel_to(stars_below_cut)) channels.add_channel(gravity_high_mass.particles.new_channel_to(stars_above_cut)) return gravity_low_mass, gravity_high_mass, bridge, channels
def setup_codes(cluster, gas, nbody_converter, gas_converter): gravity = BHTree(nbody_converter) gravity.particles.add_particles(cluster) hydro = Fi(gas_converter) hydro.parameters.eps_is_h_flag = True hydro.parameters.timestep = 0.005 | units.Myr hydro.particles.add_particles(gas) bridge = Bridge(timestep=0.01 | units.Myr, use_threading=False) bridge.add_system(gravity, (hydro, )) bridge.add_system(hydro, (gravity, )) channels = Channels() channels.add_channel(gravity.particles.new_channel_to(cluster)) channels.add_channel(hydro.particles.new_channel_to(gas)) return gravity, hydro, bridge, channels
def test16(self): numpy.random.seed(0) number_of_stars = 2 stars = plummer.new_plummer_model(number_of_stars) stars.radius = 0.00001 | nbody_system.length stars.scale_to_standard() instance = BHTree() instance.initialize_code() instance.parameters.epsilon_squared = (1.0 / 20.0 / (number_of_stars**0.33333) | nbody_system.length)**2 instance.parameters.timestep = 0.004 | nbody_system.time instance.parameters.timestep = 0.00001 | nbody_system.time instance.commit_parameters() print instance.parameters.timestep instance.particles.add_particles(stars) instance.commit_particles() energy_total_t0 = instance.potential_energy + instance.kinetic_energy request = instance.evolve_model.async(1.0 | nbody_system.time) request.result() energy_total_t1 = instance.potential_energy + instance.kinetic_energy self.assertAlmostRelativeEqual(energy_total_t0, energy_total_t1, 3) instance.stop() numpy.random.seed()
def test15(self): print "Test15: Testing effect of BHTree parameter epsilon_squared" convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) particles = datamodel.Particles(2) sun = particles[0] sun.mass = 1.0 | units.MSun sun.position = [0.0, 0.0, 0.0] | units.AU sun.velocity = [0.0, 0.0, 0.0] | units.AU / units.yr sun.radius = 1.0 | units.RSun earth = particles[1] earth.mass = 5.9736e24 | units.kg earth.radius = 6371.0 | units.km earth.position = [0.0, 1.0, 0.0] | units.AU earth.velocity = [2.0*numpy.pi, -0.0001, 0.0] | units.AU / units.yr initial_direction = math.atan((earth.velocity[0]/earth.velocity[1])) final_direction = [] for log_eps2 in range(-9,10,2): instance = BHTree(convert_nbody) instance.initialize_code() instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2 instance.particles.add_particles(particles) instance.commit_particles() instance.evolve_model(0.25 | units.yr) final_direction.append(math.atan((instance.particles[1].velocity[0]/ instance.particles[1].velocity[1]))) instance.stop() # Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees self.assertAlmostEquals(abs(final_direction[0]), abs(initial_direction+math.pi/2.0), 2) # Large values of epsilon_squared should result in ~ no interaction self.assertAlmostEquals(final_direction[-1], initial_direction, 2) # Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2 delta = [abs(final_direction[i+1]-final_direction[i]) for i in range(len(final_direction)-1)] self.assertEquals(delta[len(final_direction)//2 -1], max(delta))
def test23(self): particles = datamodel.Particles(2) particles.x = [0.0,10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.vx = 1.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 0.1 | nbody_system.mass instance = BHTree(redirection="none") instance.particles.add_particles(particles) instance.commit_particles() instance.evolve_model(0.1 | nbody_system.time) self.assertFalse(instance.particles[0].vy > 0| nbody_system.speed) self.assertAlmostRelativeEquals(instance.particles[0].x , 0.1 | nbody_system.length, 4) instance.particles.new_channel_to(particles).copy() particles.vy = 1| nbody_system.speed particles.new_channel_to(instance.particles).copy() instance.evolve_model(0.2 | nbody_system.time) self.assertTrue(instance.particles[0].vy > 0| nbody_system.speed) self.assertAlmostRelativeEquals(instance.particles[0].y , 0.1 | nbody_system.length, 4) instance.stop()
def test_bhtree(self): convert_nbody = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.km) bhtree = BHTree(convert_nbody) bhtree.parameters.epsilon_squared = 10 | units.km**2 bhtree.parameters.timestep = 1.0 | units.s bhtree.parameters.opening_angle = 0.1 docstring = bhtree.parameters.__doc__ self.assertTrue("smoothing parameter for gravity calculations (default value:125000.0 m**2)" in docstring) parameter_str_method_output = str(bhtree.parameters) self.assertTrue("epsilon_squared: 10000000.0 m**2" in parameter_str_method_output) self.assertTrue("timestep: 1.0 s" in parameter_str_method_output) self.assertTrue("opening_angle: 0.1" in parameter_str_method_output)
def test21(self): particles = datamodel.Particles(2) particles.x = [0.0, 10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass very_short_time_to_evolve = 1 | units.s very_long_time_to_evolve = 1e9 | nbody_system.time instance = BHTree() instance.initialize_code() instance.parameters.epsilon_squared = (1e-5 | nbody_system.length)**2 instance.particles.add_particles(particles) instance.commit_particles() self.assertAlmostRelativeEquals(instance.potential_energy, -0.1 | nbody_system.energy, 5) instance.stop()
def test18(self): particles = datamodel.Particles(2) particles.x = [0.0, 10.0] | nbody_system.length particles.y = 0 | nbody_system.length particles.z = 0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0 | nbody_system.speed particles.vy = 0 | nbody_system.speed particles.vz = 0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass instance = BHTree() instance.initialize_code() instance.parameters.stopping_conditions_number_of_steps = 2 self.assertEquals( instance.parameters.stopping_conditions_number_of_steps, 2) instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2 instance.particles.add_particles(particles) instance.stopping_conditions.number_of_steps_detection.enable() instance.evolve_model(10 | nbody_system.time) self.assertTrue( instance.stopping_conditions.number_of_steps_detection.is_set()) self.assertTrue(instance.model_time < 10 | nbody_system.time) instance.stop()
def test21(self): particles = datamodel.Particles(2) particles.x = [0.0,10.0] | nbody_system.length particles.y = 0.0 | nbody_system.length particles.z = 0.0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0.0 | nbody_system.speed particles.vy = 0.0 | nbody_system.speed particles.vz = 0.0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass very_short_time_to_evolve = 1 | units.s very_long_time_to_evolve = 1e9 | nbody_system.time instance = BHTree() instance.initialize_code() instance.parameters.epsilon_squared = (1e-5 | nbody_system.length)**2 instance.particles.add_particles(particles) instance.commit_particles() self.assertAlmostRelativeEquals(instance.potential_energy, -0.1 | nbody_system.energy, 5) instance.stop()
def test18(self): particles = datamodel.Particles(2) particles.x = [0.0,10.0] | nbody_system.length particles.y = 0 | nbody_system.length particles.z = 0 | nbody_system.length particles.radius = 0.005 | nbody_system.length particles.vx = 0 | nbody_system.speed particles.vy = 0 | nbody_system.speed particles.vz = 0 | nbody_system.speed particles.mass = 1.0 | nbody_system.mass instance = BHTree() instance.initialize_code() instance.parameters.stopping_conditions_number_of_steps = 2 self.assertEquals(instance.parameters.stopping_conditions_number_of_steps, 2) instance.parameters.epsilon_squared = (0.01 | nbody_system.length)**2 instance.particles.add_particles(particles) instance.stopping_conditions.number_of_steps_detection.enable() instance.evolve_model(10 | nbody_system.time) self.assertTrue(instance.stopping_conditions.number_of_steps_detection.is_set()) self.assertTrue(instance.model_time < 10 | nbody_system.time) instance.stop()
def init_integrator(method): if method == 'octgrav': gravity = Octgrav() elif method == 'ph4': gravity = ph4() elif method == 'fi': gravity = Fi(convert_nbody) gravity.initialize_code() gravity.parameters.epsilon_squared = 0.00000001 | units.AU**2 gravity.parameters.timestep = .10 | units.day elif method == 'phigrape': gravity = PhiGRAPE(convert_nbody, mode=PhiGRAPEInterface.MODE_GPU) elif method == 'bhtree': gravity = BHTree(convert_nbody, number_of_workes=workers) elif method == 'hermite': gravity = Hermite(convert_nbody, number_of_workers=workers #debugger = "xterm", #redirection = "none" ) gravity.parameters.epsilon_squared = 0.00001 | units.AU**2 return gravity
def nbody_integrator(Ncl, mcl, rcl, t_end, n_steps, escape_velocity_fraction, R): converter = nbody_system.nbody_to_si(mcl, rcl) bodies = new_plummer_model(Ncl, convert_nbody=converter) #estimate of milky way mass by "Mass models of the Milky Way", McMillan blackhole_mass = 1.26e12 | units.MSun blackhole = Particle(mass=blackhole_mass) blackhole.position = [0, 0, 0] | units.m cluster_velocity = [0, 0, 0] | units.m / units.s cluster_position = [0, 0, 0] | units.parsec cluster_position[0] = R G_si = converter.to_si(nbody_system.G) escape_v = (2 * G_si * blackhole_mass / R).sqrt().as_quantity_in(units.m / units.s) V = escape_v * escape_velocity_fraction cluster_velocity[1] = V bodies.move_to_center() bodies.velocity += cluster_velocity bodies.position += cluster_position bodies.add_particle(blackhole) gravity = BHTree(converter) gravity.particles.add_particles(bodies) channel_from_gravity_to_framework = gravity.particles.\ new_channel_to(bodies) time = zero dt = t_end / float(n_steps) x = 0 base_path = "encounter_plots/"+str(R.value_in(units.parsec))+"_"+\ str(escape_velocity_fraction)+"_" while time < t_end: plot_cluster(bodies, base_path + str(x), time, rcl, V) time += dt gravity.evolve_model(time) channel_from_gravity_to_framework.copy() x += 1 plot_cluster(bodies, base_path + str(x), time, rcl, V) gravity.stop() return V, bodies
def test13(self): convert_nbody = nbody_system.nbody_to_si(1.0 | units.kg, 1.0 | units.m) instance = BHTree(convert_nbody) instance.commit_parameters() particles = datamodel.Particles(2) self.assertEquals(len(instance.particles), 0) particles.mass = [30.0, 30.0] | units.kg particles.radius = [1.0, 1.0] | units.m particles.position = [[-10.0, 0.0, 0.0], [10.0, 0.0, 0.0]] | units.m particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s instance.particles.add_particles(particles) instance.commit_particles() copyof = instance.particles.copy() com = instance.center_of_mass_position self.assertAlmostEqual(com[0], quantities.new_quantity(0.0, units.m), constants.precision) instance.stop()
def new_code_to_calculate_gravity_of_gas_particles(): result = BHTree(self.converter) return result
def test3(self): instance = BHTree() self._run_addition_removal_test(instance)
def test14(self): print "Test14: Testing BHTree parameters (I)" convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU) instance = BHTree(convert_nbody) value, error = instance.legacy_interface.get_epsilon_squared() self.assertEquals(0, error) self.assertEquals(0.125, value) self.assertAlmostEquals(0.125 | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2) for x in [0.01, 0.1, 0.2]: instance.parameters.epsilon_squared = x | units.AU**2 self.assertAlmostEquals(x | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2) (value, error) = instance.legacy_interface.get_time_step() self.assertEquals(0, error) self.assertEquals(0.015625, value) self.assertAlmostEquals(0.015625 | units.yr, instance.parameters.timestep, in_units=units.yr) for x in [0.001, 0.01, 0.1]: instance.parameters.timestep = x | units.yr self.assertAlmostEquals(x | units.yr, instance.parameters.timestep, in_units=units.yr) (value, error) = instance.legacy_interface.get_theta_for_tree() self.assertEquals(0, error) self.assertEquals(0.75, value) self.assertEquals(0.75, instance.parameters.opening_angle) for x in [0.2, 0.5, 0.7]: instance.parameters.opening_angle = x self.assertEquals(x, instance.parameters.opening_angle) (value, error) = instance.legacy_interface.get_use_self_gravity() self.assertEquals(0, error) self.assertEquals(1, value) self.assertEquals(1, instance.parameters.use_self_gravity) for x in [0, 1]: instance.parameters.use_self_gravity = x self.assertEquals(x, instance.parameters.use_self_gravity) (value, error) = instance.legacy_interface.get_ncrit_for_tree() self.assertEquals(0, error) self.assertEquals(12, value) self.assertEquals(12, instance.parameters.ncrit_for_tree) for x in [512, 2048, 4096]: instance.parameters.ncrit_for_tree = x self.assertEquals(x, instance.parameters.ncrit_for_tree) (value, error) = instance.legacy_interface.get_dt_dia() self.assertEquals(0, error) self.assertEquals(1.0, value) self.assertAlmostEquals(1.0 | units.yr, instance.parameters.dt_dia, in_units=units.yr) for x in [0.1, 10.0, 100.0]: instance.parameters.dt_dia = x | units.yr self.assertAlmostEquals(x | units.yr, instance.parameters.dt_dia, in_units=units.yr) instance.stop()
def test12(self): convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m) instance = BHTree(convert_nbody) instance.commit_parameters() particles = datamodel.Particles(2) self.assertEquals(len(instance.particles), 0) particles.mass = [15.0, 30.0] | units.kg particles.radius = [10.0, 20.0] | units.m particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0] ] | units.m / units.s instance.particles.add_particles(particles) instance.commit_particles() copyof = instance.particles.copy() instance.set_state(1, 16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m, 1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms) curr_state = instance.get_state(1) for expected, actual in zip( (16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m, 1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 0 | units.m), curr_state): self.assertAlmostRelativeEquals(actual, expected) instance.set_state(1, 16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m, 1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 20.0 | units.m) curr_state = instance.get_state(1) for expected, actual in zip( (16 | units.kg, 20.0 | units.m, 40.0 | units.m, 60.0 | units.m, 1.0 | units.ms, 1.0 | units.ms, 1.0 | units.ms, 20 | units.m), curr_state): self.assertAlmostRelativeEquals(actual, expected) instance.stop()
def simulate_small_cluster(number_of_stars, end_time=40 | units.Myr, name_of_the_figure="test-2.svg"): # numpy.random.seed(1) salpeter_masses = new_salpeter_mass_distribution(number_of_stars) total_mass = salpeter_masses.sum() convert_nbody = nbody_system.nbody_to_si(total_mass, 1.0 | units.parsec) particles = new_plummer_model(number_of_stars, convert_nbody) gravity = BHTree(convert_nbody) # print gravity.parameters.timestep.as_quantity_in(units.Myr) gravity.parameters.timestep = 0.0001 | units.Myr # tiny! gravity.parameters.epsilon_squared \ = (float(number_of_stars)**(-0.333333) | units.parsec) ** 2 stellar_evolution = SSE() print "setting masses of the stars" particles.radius = 0.0 | units.RSun particles.mass = salpeter_masses print "initializing the particles" stellar_evolution.particles.add_particles(particles) from_stellar_evolution_to_model \ = stellar_evolution.particles.new_channel_to(particles) from_stellar_evolution_to_model.copy_attributes(["mass"]) print "centering the particles" particles.move_to_center() print "scaling particles to viridial equilibrium" particles.scale_to_standard(convert_nbody) gravity.particles.add_particles(particles) from_model_to_gravity = particles.new_channel_to(gravity.particles) from_gravity_to_model = gravity.particles.new_channel_to(particles) time = 0.0 | units.Myr particles.savepoint(time) total_energy_at_t0 = gravity.kinetic_energy + gravity.potential_energy print "evolving the model until t = " + str(end_time) while time < end_time: time += 0.25 | units.Myr print "gravity evolve step starting" gravity.evolve_model(time) print "gravity evolve step done" print "stellar evolution step starting" stellar_evolution.evolve_model(time) print "stellar evolution step done" from_gravity_to_model.copy() from_stellar_evolution_to_model.copy_attributes(["mass", "radius"]) particles.savepoint(time) from_model_to_gravity.copy_attributes(["mass"]) total_energy_at_this_time \ = gravity.kinetic_energy + gravity.potential_energy print_log(time, gravity, particles, total_energy_at_t0, total_energy_at_this_time) test_results_path = get_path_to_results() output_file = os.path.join(test_results_path, "small.hdf5") if os.path.exists(output_file): os.remove(output_file) storage = store.StoreHDF(output_file) storage.store(particles) gravity.stop() stellar_evolution.stop() plot_particles(particles, name_of_the_figure)
def test17(self): print "Testing BHTree collision_detection" particles = datamodel.Particles(7) particles.mass = 0.001 | 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 = BHTree(redirection='none') instance.initialize_code() instance.parameters.set_defaults() # Uncommenting any of the following two lines will suppress collision detection #~ instance.parameters.use_self_gravity = 0 #~ instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2 instance.parameters.opening_angle = 0.1 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 = datamodel.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 test12(self): convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m) instance = BHTree(convert_nbody) instance.commit_parameters() particles = datamodel.Particles(2) self.assertEquals(len(instance.particles), 0) particles.mass = [15.0, 30.0] | units.kg particles.radius = [10.0, 20.0] | units.m particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s instance.particles.add_particles(particles) instance.commit_particles() copyof = instance.particles.copy() instance.set_state(1, 16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m, 1.0|units.ms, 1.0|units.ms, 1.0|units.ms) curr_state = instance.get_state(1) for expected, actual in zip((16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m, 1.0|units.ms, 1.0|units.ms, 1.0|units.ms, 0 | units.m), curr_state): self.assertAlmostRelativeEquals(actual,expected) instance.set_state(1, 16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m, 1.0|units.ms, 1.0|units.ms, 1.0|units.ms , 20.0|units.m) curr_state = instance.get_state(1) for expected, actual in zip((16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m, 1.0|units.ms, 1.0|units.ms, 1.0|units.ms, 20 | units.m), curr_state): self.assertAlmostRelativeEquals(actual,expected) instance.stop()
def assignment_2d(): current_cluster_mass = 400 | units.MSun initial_mass_fraction = 0.84 desired_initial_mass = current_cluster_mass / initial_mass_fraction masses = new_salpeter_mass_distribution(100000) mean_salpeter_mass = masses.mean() print "mean salpeter mass", mean_salpeter_mass N = int(desired_initial_mass / mean_salpeter_mass) print "N", N Rvir = 10 | units.lightyear z = 0.17 masses = new_salpeter_mass_distribution(N) converter = nbody_system.nbody_to_si(masses.sum(), Rvir) G_SI = converter.to_si(nbody_system.G) bodies = new_plummer_sphere(N, convert_nbody=converter) bodies.mass = masses bodies.metalicity = z # start the gravity solver gravity = BHTree(converter) gravity.initialize_code() gravity.parameters.timestep = 0.1 | units.Myr # start the stellar evolution solver stellar = SSE() stars = stellar.particles.add_particles(bodies) from_stellar_evolution_to_model \ = stellar.particles.new_channel_to(bodies) from_stellar_evolution_to_model.copy_attributes(["mass"]) bodies.scale_to_standard(converter) gravity.particles.add_particles(bodies) from_model_to_gravity = bodies.new_channel_to(gravity.particles) from_gravity_to_model = gravity.particles.new_channel_to(bodies) gravity.commit_particles() end_time = 1000 | units.Myr current_time = 0 | units.Myr cluster = "Hyades" bound_stars_counts = [] main_sequence_stars_counts = [] giant_stars_counts = [] remnant_stars_counts = [] max_radii = [] | units.parsec virial_radii = [] | units.parsec times = [] | units.Myr while current_time < end_time: name_of_the_figure = "isochrone_with_grav_"+str(int(current_time.value_in(units.Myr)))+".png" gravity.evolve_model(current_time) stellar.evolve_model(current_time) from_gravity_to_model.copy() from_stellar_evolution_to_model.copy_attributes(["mass", "radius"]) from_model_to_gravity.copy_attributes(["mass"]) remnant_count = 0 main_sequence_count = 0 giant_count = 0 for star in stars: if stellar_remnant_state(star): remnant_count += 1 if stellar_giant_state(star): giant_count += 1 if stellar_main_sequence_state(star): main_sequence_count += 1 max_radius = bodies.total_radius() virial_radius = bodies.virial_radius() bound_star_count = len(bodies.bound_subset(unit_converter=converter, G=G_SI)) print "bound stars:", bound_star_count print "main sequence stars:", main_sequence_count print "giant stars:", giant_count print "remnant stars:", remnant_count print "cluster radius(max from centre):", max_radius print "virial radius:", virial_radius print current_time times.append(current_time) remnant_stars_counts.append(remnant_count) giant_stars_counts.append(giant_count) main_sequence_stars_counts.append(main_sequence_count) max_radii.append(max_radius) virial_radii.append(virial_radius) bound_stars_counts.append(bound_star_count) temperatures = stars.temperature luminosities = stars.luminosity plot_HR_diagram(temperatures, luminosities, cluster+"/", name_of_the_figure, current_time) current_time += 10 | units.Myr data = {} data["bound_stars_at_time"] = bound_stars_counts data["remnant_stars_at_time"] = remnant_stars_counts data["giant_stars_at_time"] = giant_stars_counts data["main_sequence_stars_at_time"] = main_sequence_stars_counts data["max_radius_at_time"] = max_radii data["virial_radii"] = virial_radii data["times"] = times pickle.dump(data, open(cluster+"/assignment2d.dat", "wb"))
def test1(self): convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km) instance = BHTree(convert_nbody) instance.parameters.epsilon_squared = 0.001 | units.AU**2 stars = datamodel.Stars(2) sun = stars[0] sun.mass = units.MSun(1.0) sun.position = [0.0,0.0,0.0] | units.m sun.velocity = [0.0,0.0,0.0] | units.ms sun.radius = units.RSun(1.0) earth = stars[1] earth.mass = units.kg(5.9736e24) earth.radius = units.km(6371) earth.position = [149.5e6, 0.0, 0.0] | units.km earth.velocity = [0.0, 29800, 0.0] | units.ms #instance.particles.add_particles(stars) instance.particles.add_particles(stars) postion_at_start = earth.position.value_in(units.AU)[0] instance.evolve_model(365.0 | units.day) instance.particles.copy_values_of_all_attributes_to(stars) postion_after_full_rotation = earth.position.value_in(units.AU)[0] self.assertAlmostEqual(postion_at_start, postion_after_full_rotation, 3) instance.evolve_model(365.0 + (365.0 / 2) | units.day) instance.particles.copy_values_of_all_attributes_to(stars) postion_after_half_a_rotation = earth.position.value_in(units.AU)[0] self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 2) instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day) instance.particles.copy_values_of_all_attributes_to(stars) postion_after_half_a_rotation = earth.position.value_in(units.AU)[1] self.assertAlmostEqual(-postion_at_start, postion_after_half_a_rotation, 1) instance.cleanup_code() instance.stop()
def test2(self): convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km) bhtree = BHTree(convert_nbody) bhtree.initialize_code() bhtree.eps2_for_gravity = 0.001 bhtree_particles = self.new_system_sun_and_earth() bhtree.particles.add_particles(bhtree_particles) if bhtree.legacy_interface.channel_type == 'mpi': from mpi4py import MPI if not MPI.Query_thread() == MPI.THREAD_MULTIPLE: bhtree.stop() self.skip("can only test parallel with multiple thread support in mpi implementation") hermite = Hermite(convert_nbody) hermite.dt_dia = 5000 hermite.commit_parameters() hermite_particles = self.new_system_sun_and_earth() hermite.particles.add_particles(hermite_particles) thread1 = threading.Thread(target = self.evolve_model_unit_day, args = (bhtree, bhtree_particles, 10)) thread2 = threading.Thread(target = self.evolve_model_unit_day, args = (hermite, hermite_particles, 10)) thread1.start() thread2.start() thread1.join() thread2.join() if HAS_MATPLOTLIB: figure = pyplot.figure() plot = figure.add_subplot(1,1,1) earth = bhtree_particles[1] x_points = earth.get_timeline_of_attribute("x") y_points = earth.get_timeline_of_attribute("y") x_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), x_points) y_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), y_points) plot.scatter(x_points_in_AU,y_points_in_AU, color = "b", marker = 'o') earth = hermite_particles[1] x_points = earth.get_timeline_of_attribute("x") y_points = earth.get_timeline_of_attribute("y") x_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), x_points) y_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), y_points) plot.scatter(x_points_in_AU,y_points_in_AU, color = "g", marker = 'o') plot.set_xlim(-1.5, 1.5) plot.set_ylim(-1.5, 1.5) test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "parallel-earth-sun.svg") figure.savefig(output_file) bhtree.stop() hermite.stop() bhtree.stop()
def test3(self): convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km) instance = BHTree(convert_nbody) #instance.dt_dia = 1 instance.parameters.epsilon_squared = 0.001 | units.AU**2 #instance.timestep = 0.0001 #instance.use_self_gravity = 0 instance.commit_parameters() stars = datamodel.Stars(2) star1 = stars[0] star2 = stars[1] star1.mass = units.MSun(1.0) star1.position = units.AU(numpy.array((-.10,0.0,0.0))) star1.velocity = units.AUd(numpy.array((0.0,0.0,0.0))) star1.radius = units.RSun(1.0) star2.mass = units.MSun(1.0) star2.position = units.AU(numpy.array((.10,0.0,0.0))) star2.velocity = units.AUd(numpy.array((0.0,0.0,0.0))) star2.radius = units.RSun(100.0) instance.particles.add_particles(stars) instance.commit_particles() for x in range(1,200,1): instance.evolve_model(x | units.day) instance.particles.copy_values_of_all_attributes_to(stars) #instance.get_indices_of_colliding_particles() #print stars[0].position-stars[1].position stars.savepoint() instance.cleanup_code() instance.stop()
def test4(self): convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m) instance = BHTree(convert_nbody) instance.commit_parameters() index = instance.new_particle( 15.0 | units.kg, 10.0 | units.m, 20.0 | units.m, 30.0 | units.m, #1.0 | units.m/units.s, 1.0 | units.m/units.s, 3.0 | units.m/units.s 0.0 | units.m/units.s, 0.0 | units.m/units.s, 0.0 | units.m/units.s, 10.0 | units.m ) instance.commit_particles() self.assertEquals(instance.get_mass(index), 15.0| units.kg) self.assertEquals(instance.get_radius(index), 10.0| units.m) instance.cleanup_code() instance.stop()
def test5(self): instance = BHTree() instance.commit_parameters() index = instance.new_particle( 15.0 | nbody_system.mass, 10.0 | nbody_system.length, 20.0 | nbody_system.length, 30.0 | nbody_system.length, 1.0 | nbody_system.speed, 1.0 | nbody_system.speed, 3.0 | nbody_system.speed, 10.0 | nbody_system.length ) instance.commit_particles() self.assertEquals(instance.get_mass(index), 15.0| nbody_system.mass) self.assertEquals(instance.get_radius(index), 10.0| nbody_system.length) instance.cleanup_code() instance.stop()
def test6(self): convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m) instance = BHTree(convert_nbody) instance.commit_parameters() indices = instance.new_particle( [15.0, 30.0] | units.kg, [10.0, 20.0] | units.m, [20.0, 40.0] | units.m, [30.0, 50.0] | units.m, #1.0 | units.m/units.s, 1.0 | units.m/units.s, 3.0 | units.m/units.s [0.0, 0.01] | units.m/units.s, [0.0, 0.01] | units.m/units.s, [0.0, 0.01] | units.m/units.s, [10.0, 20.0] | units.m ) instance.commit_particles() self.assertEquals(instance.get_mass(indices[0]), 15.0| units.kg) self.assertEquals(instance.get_mass(indices)[0], 15.0| units.kg) self.assertRaises(AmuseException, instance.get_mass, [4,5], expected_message = "Error when calling 'get_mass' of a 'BHTree', errorcode is -1") instance.cleanup_code() instance.stop()
def test10(self): instance = BHTree() instance.initialize_code() instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2 instance.commit_parameters() particles = datamodel.Particles(6) particles.mass = 1.0 | nbody_system.mass particles.radius = 0.00001 | nbody_system.length particles.position = [[-1.0,0.0,0.0],[1.0,0.0,0.0],[0.0,-1.0,0.0],[0.0,1.0,0.0],[0.0,0.0,-1.0],[0.0,0.0,1.0]] | nbody_system.length particles.velocity = [[0.0,0.0,0.0],[0.0,0.0,0.0],[0.0,0.0,0.0],[0.0,0.0,0.0],[0.0,0.0,0.0],[0.0,0.0,0.0]] | nbody_system.speed instance.particles.add_particles(particles) instance.commit_particles() zero = 0.0 | nbody_system.length fx, fy, fz = instance.get_gravity_at_point(zero, zero, zero, zero) self.assertAlmostEqual(fx, 0.0 | nbody_system.acceleration, 3) self.assertAlmostEqual(fy, 0.0 | nbody_system.acceleration, 3) self.assertAlmostEqual(fz, 0.0 | nbody_system.acceleration, 3) for position in (0.25, 0.5, 0.75): p0 = position | nbody_system.length p1 = -position | nbody_system.length for i in range(3): args0 = [zero] * 4 args1 = [zero] * 4 args0[1 + i] = p0 args1[1 + i] = p1 f0 = instance.get_gravity_at_point(*args0) f1 = instance.get_gravity_at_point(*args1) for j in range(3): if j != i: self.assertAlmostEqual(f0[j], 0.0 | nbody_system.acceleration, 3) self.assertAlmostEqual(f1[j], 0.0 | nbody_system.acceleration, 3) else: self.assertAlmostEqual(f0[j], -1.0 * f1[j], 5) instance.stop()
def test2(self): #not completed convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km) instance = BHTree(convert_nbody) #instance.dt_dia = 1 instance.parameters.epsilon_squared = 0.001 | units.AU**2 #instance.timestep = 0.0001 #instance.use_self_gravity = 0 instance.commit_parameters() stars = datamodel.Stars(2) sun = stars[0] sun.mass = units.MSun(1.0) sun.position = units.m(numpy.array((0.0,0.0,0.0))) sun.velocity = units.ms(numpy.array((0.0,0.0,0.0))) sun.radius = units.RSun(1.0) earth = stars[1] earth.mass = units.kg(5.9736e24) earth.radius = units.km(6371) earth.position = units.km(numpy.array((149.5e6,0.0,0.0))) earth.velocity = units.ms(numpy.array((0.0,29800,0.0))) instance.particles.add_particles(stars) instance.commit_particles() self.assertAlmostRelativeEquals(sun.radius, instance.particles[0].radius) for x in range(1,2000,10): instance.evolve_model(x | units.day) instance.particles.copy_values_of_all_attributes_to(stars) stars.savepoint() if HAS_MATPLOTLIB: figure = pyplot.figure() plot = figure.add_subplot(1,1,1) x_points = earth.get_timeline_of_attribute("x") y_points = earth.get_timeline_of_attribute("y") x_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), x_points) y_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), y_points) plot.scatter(x_points_in_AU,y_points_in_AU, color = "b", marker = 'o') plot.set_xlim(-1.5, 1.5) plot.set_ylim(-1.5, 1.5) test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "bhtree-earth-sun.svg") figure.savefig(output_file) instance.cleanup_code() instance.stop()
def simulate_small_cluster(number_of_stars, end_time=40 | units.Myr, name_of_the_figure="test-2.svg"): # numpy.random.seed(1) salpeter_masses = new_salpeter_mass_distribution(number_of_stars) total_mass = salpeter_masses.sum() convert_nbody = nbody_system.nbody_to_si(total_mass, 1.0 | units.parsec) particles = new_plummer_model(number_of_stars, convert_nbody) gravity = BHTree(convert_nbody) gravity.initialize_code() # gravity.parameters.set_defaults() # print gravity.parameters.timestep.as_quantity_in(units.Myr) gravity.parameters.timestep = 0.0001 | units.Myr # tiny! gravity.parameters.epsilon_squared \ = (float(number_of_stars)**(-0.333333) | units.parsec) ** 2 stellar_evolution = SSE() stellar_evolution.initialize_module_with_default_parameters() print "setting masses of the stars" particles.radius = 0.0 | units.RSun particles.mass = salpeter_masses print "initializing the particles" stellar_evolution.particles.add_particles(particles) from_stellar_evolution_to_model \ = stellar_evolution.particles.new_channel_to(particles) from_stellar_evolution_to_model.copy_attributes(["mass"]) print "centering the particles" particles.move_to_center() print "scaling particles to viridial equilibrium" particles.scale_to_standard(convert_nbody) gravity.particles.add_particles(particles) from_model_to_gravity = particles.new_channel_to(gravity.particles) from_gravity_to_model = gravity.particles.new_channel_to(particles) gravity.commit_particles() time = 0.0 | units.Myr particles.savepoint(time) total_energy_at_t0 = gravity.kinetic_energy + gravity.potential_energy print "evolving the model until t = " + str(end_time) while time < end_time: time += 0.25 | units.Myr print "Gravity evolve step starting" gravity_evolve = gravity.evolve_model.async(time) print "Stellar evolution step starting" stellar_evolution_evolve = stellar_evolution.evolve_model(time) print "Stellar evolution step done." gravity_evolve.result() print "Gravity evolve step done." from_gravity_to_model.copy() from_stellar_evolution_to_model.copy_attributes(["mass", "radius"]) particles.savepoint(time) from_model_to_gravity.copy_attributes(["mass"]) total_energy_at_this_time \ = gravity.kinetic_energy + gravity.potential_energy print_log(time, gravity, particles, total_energy_at_t0, total_energy_at_this_time) test_results_path = get_path_to_results() output_file = os.path.join(test_results_path, "small.hdf5") if os.path.exists(output_file): os.remove(output_file) storage = store.StoreHDF(output_file) storage.store(particles) gravity.stop() stellar_evolution.stop() plot_particles(particles, name_of_the_figure)