def evolve_model(self, model_time): start_time = time.time() density_limit_detection = self.code.stopping_conditions.density_limit_detection density_limit_detection.enable() model_time_old = self.code.model_time dt = model_time - model_time_old print("Evolve Hydrodynamics:", dt.in_(units.yr)) if COOL: print("Cool gas for dt=", (dt / 2).in_(units.Myr)) self.cooling.evolve_for(dt / 2) # print "...done." self.code.evolve_model(model_time) # print "gas evolved." while density_limit_detection.is_set(): self.resolve_sinks() print("..done") self.code.evolve_model(model_time) self.channel_to_stars.copy() print("end N=", len(self.star_particles), len(self.code.dm_particles)) if COOL: print("Cool gas for another dt=", (dt / 2).in_(units.Myr)) self.cooling.evolve_for(dt / 2) # print "...done." self.merge_stars() if len(self.star_particles) > 0: sinks = new_sink_particles(self.star_particles) sinks.accrete(self.gas_particles) for si in range(len(self.star_particles)): self.star_particles[si].Lx += sinks[si].angular_momentum[0] self.star_particles[si].Ly += sinks[si].angular_momentum[1] self.star_particles[si].Lz += sinks[si].angular_momentum[2] self.gas_particles.synchronize_to(self.code.gas_particles) # make sure that the accreted mass is copied to the Hydro code..+++ self.channel_from_stars.copy() # self.code.evolve_model(model_time) print("final N=", len(self.star_particles), len(self.code.dm_particles)) print("final Ngas=", len(self.gas_particles), len(self.code.gas_particles)) self.channel_to_gas.copy() self.channel_to_stars.copy() print("final N=", len(self.star_particles), len(self.code.dm_particles)) if len(self.star_particles) > 0: print("mean star mass:", self.star_particles.mass.min().in_(units.MSun), self.star_particles.mass.mean().in_(units.MSun), self.star_particles.mass.max().in_(units.MSun))
def test2(self): """ Test Spheroid sink accretion """ particles = self.create_particle_grid() spheroid = sink.Spheroid([5., 4., 1.] | units.RSun) sink_particles = Particles(1, mass=10. | units.MSun, radius=0. | units.RSun, position=[[1., 1., 1.]] | units.RSun) sinks = new_sink_particles(sink_particles, shapes=spheroid) accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 161) self.assertEqual(len(particles), 1839) self.assertEqual(accreted.x.max(), 4 | units.RSun) self.assertEqual(accreted.y.max(), 3 | units.RSun) self.assertEqual(accreted.z.max(), 0.5 | units.RSun) spheroid.dimensions[2] = 3 | units.RSun accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 324) self.assertEqual(len(particles), 1515) self.assertEqual(accreted.x.max(), 4 | units.RSun) self.assertEqual(accreted.y.max(), 3 | units.RSun) self.assertEqual(accreted.z.max(), 2.5 | units.RSun) self.assertIsSubvector([3, 2, 2.5] | units.RSun, particles.position)
def evolve_model(self, model_time): start_time = time.time() density_limit_detection = self.code.stopping_conditions.density_limit_detection density_limit_detection.enable() model_time_old=self.code.model_time dt=model_time - model_time_old print "Evolve Hydrodynamics:", dt.in_(units.yr) if COOL: print "Cool gas for dt=", (dt/2).in_(units.Myr) self.cooling.evolve_for(dt/2) #print "...done." self.code.evolve_model(model_time) #print "gas evolved." while density_limit_detection.is_set(): self.resolve_sinks() print "..done" self.code.evolve_model(model_time) self.channel_to_stars.copy() print "end N=", len(self.star_particles), len(self.code.dm_particles) if COOL: print "Cool gas for another dt=", (dt/2).in_(units.Myr) self.cooling.evolve_for(dt/2) #print "...done." self.merge_stars() if len(self.star_particles)>0: sinks = new_sink_particles(self.star_particles) sinks.accrete(self.gas_particles) for si in range(len(self.star_particles)): self.star_particles[si].Lx += sinks[si].angular_momentum[0] self.star_particles[si].Ly += sinks[si].angular_momentum[1] self.star_particles[si].Lz += sinks[si].angular_momentum[2] self.gas_particles.synchronize_to(self.code.gas_particles) # make sure that the accreted mass is copied to the Hydro code..+++ self.channel_from_stars.copy() #self.code.evolve_model(model_time) print "final N=", len(self.star_particles),len(self.code.dm_particles) print "final Ngas=", len(self.gas_particles),len(self.code.gas_particles) self.channel_to_gas.copy() self.channel_to_stars.copy() print "final N=", len(self.star_particles),len(self.code.dm_particles) if len(self.star_particles)>0: print "mean star mass:", self.star_particles.mass.min().in_(units.MSun), self.star_particles.mass.mean().in_(units.MSun), self.star_particles.mass.max().in_(units.MSun)
def test2(self): print("Demonstrate new_sink_particles usage") cloud = Particles(100) cloud.mass = 1 | units.MSun cloud.position = [[0, 0, 0], [100, 100, 100], [200, 200, 200], [300, 300, 300]] * 25 | units.parsec cloud.velocity = [[0, 0, 0], [1, 1, 1]] * 50 | units.km / units.s unit_converter = ConvertBetweenGenericAndSiUnits( 1 | units.m, 1 | units.kg, 1 | units.s) sph_code = Stub(unit_converter) sph_code.parameters.stopping_condition_maximum_density = 1 | units.kg / units.m**3 sph_code.gas_particles.add_particles(cloud) density_limit_detection = sph_code.stopping_conditions.density_limit_detection density_limit_detection.enable() sph_code.evolve_model(1 | units.Myr) self.assertTrue(density_limit_detection.is_set()) self.assertEqual(len(density_limit_detection.particles()), 3) self.assertEqual(density_limit_detection.particles().position, [[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec) print(density_limit_detection.particles()) clumps = density_limit_detection.particles().copy() sph_code.gas_particles.remove_particles(clumps) sinks = new_sink_particles(clumps, sink_radius=1 | units.parsec, looping_over=self.looping_over) self.assertEqual(sinks.sink_radius, 1.0 | units.parsec) self.assertEqual(sinks.mass, 1.0 | units.MSun) self.assertEqual(sinks.position, [[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec) self.assertEqual(len(sph_code.gas_particles), 97) self.assertAlmostRelativeEqual( sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 97 | units.MSun, 10) sinks.accrete(sph_code.gas_particles) self.assertAlmostRelativeEqual(sinks.mass, [25, 25, 25] | units.MSun, 10) self.assertEqual(len(sph_code.gas_particles), 25) self.assertAlmostRelativeEqual( sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 25 | units.MSun, 10)
def test3(self): """ Test compound sink accretion """ particles = self.create_particle_grid() shape = sink.Sphere(3.|units.RSun) | sink.Disc(*[5., 1.]|units.RSun) sink_particles = Particles(1, mass=10.|units.MSun, radius=0.|units.RSun, position=[[1., 1., 1.]]|units.RSun) sinks = new_sink_particles(sink_particles, shapes=shape) accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 319) self.assertEqual(len(particles), 1681) self.assertEqual(accreted.x.max(), 4|units.RSun) self.assertEqual(accreted.y.max(), 4|units.RSun) self.assertEqual(accreted.z.max(), 2.5|units.RSun) self.assertIsSubvector([2, 2, 1]|units.RSun, particles.position)
def test3(self): """ Test compound sink accretion """ particles = self.create_particle_grid() shape = sink.Sphere(3.|units.RSun) | sink.Disc(*[5., 1.]|units.RSun) sink_particles = Particles(1, mass=10.|units.MSun, radius=0.|units.RSun, position=[1., 1., 1.]|units.RSun) sinks = new_sink_particles(sink_particles, shapes=shape) accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 319) self.assertEqual(len(particles), 1681) self.assertEqual(accreted.x.max(), 4|units.RSun) self.assertEqual(accreted.y.max(), 4|units.RSun) self.assertEqual(accreted.z.max(), 2.5|units.RSun) self.assertIsSubvector([2, 2, 1]|units.RSun, particles.position)
def evolve_system(coupled_system, t_end, n_steps): times = (t_end * range(1, n_steps+1) / n_steps).as_quantity_in(units.day) sinks = new_sink_particles(coupled_system.codes[0].particles, sink_radius=5|units.RSun) for i_step, time in enumerate(times): sinks.accrete(coupled_system.gas_particles) coupled_system.evolve_model(time) print " Evolved to:", time if i_step % 10 == 9: snapshotfile = os.path.join("snapshots", "hydro_triple_{0:=06}_gas.amuse".format(i_step)) write_set_to_file(coupled_system.gas_particles, snapshotfile, format='amuse') snapshotfile = os.path.join("snapshots", "hydro_triple_{0:=06}_dm.amuse".format(i_step)) write_set_to_file(coupled_system.dm_particles, snapshotfile, format='amuse') coupled_system.stop()
def test2(self): """ Test Spheroid sink accretion """ particles = self.create_particle_grid() spheroid = sink.Spheroid([5., 4., 1.]|units.RSun) sink_particles = Particles(1, mass=10.|units.MSun, radius=0.|units.RSun, position=[1., 1., 1.]|units.RSun) sinks = new_sink_particles(sink_particles, shapes=spheroid) accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 161) self.assertEqual(len(particles), 1839) self.assertEqual(accreted.x.max(), 4|units.RSun) self.assertEqual(accreted.y.max(), 3|units.RSun) self.assertEqual(accreted.z.max(), 0.5|units.RSun) spheroid.dimensions[2] = 3 | units.RSun accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 324) self.assertEqual(len(particles), 1515) self.assertEqual(accreted.x.max(), 4|units.RSun) self.assertEqual(accreted.y.max(), 3|units.RSun) self.assertEqual(accreted.z.max(), 2.5|units.RSun) self.assertIsSubvector([3, 2, 2.5]|units.RSun, particles.position)
def test2(self): print "Demonstrate new_sink_particles usage" cloud = Particles(100) cloud.mass = 1 | units.MSun cloud.position = [[0, 0, 0], [100, 100, 100], [200, 200, 200], [300, 300, 300]]*25 | units.parsec cloud.velocity = [[0, 0, 0], [1, 1, 1]]*50 | units.km / units.s unit_converter = ConvertBetweenGenericAndSiUnits(1|units.m, 1|units.kg, 1|units.s) sph_code = Stub(unit_converter) sph_code.parameters.stopping_condition_maximum_density = 1 | units.kg / units.m**3 sph_code.gas_particles.add_particles(cloud) density_limit_detection = sph_code.stopping_conditions.density_limit_detection density_limit_detection.enable() sph_code.evolve_model(1 | units.Myr) self.assertTrue(density_limit_detection.is_set()) self.assertEqual(len(density_limit_detection.particles()), 3) self.assertEqual(density_limit_detection.particles().position, [[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec) print density_limit_detection.particles() clumps = density_limit_detection.particles().copy() sph_code.gas_particles.remove_particles(clumps) sinks = new_sink_particles(clumps, sink_radius=1|units.parsec,looping_over=self.looping_over) self.assertEqual(sinks.sink_radius, 1.0 | units.parsec) self.assertEqual(sinks.mass, 1.0 | units.MSun) self.assertEqual(sinks.position, [[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec) self.assertEqual(len(sph_code.gas_particles), 97) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 97 | units.MSun, 10) sinks.accrete(sph_code.gas_particles) self.assertAlmostRelativeEqual(sinks.mass, [25, 25, 25] | units.MSun, 10) self.assertEqual(len(sph_code.gas_particles), 25) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 25 | units.MSun, 10)
def test3(self): print("Demonstrate new_sink_particles usage (using Gadget2)") UnitLength = 1.0 | units.kpc UnitMass = 1.0e10 | units.MSun UnitVelocity = 1.0 | units.km / units.s convert_nbody = nbody_system.nbody_to_si(UnitLength, UnitMass) converter = ConvertBetweenGenericAndSiUnits(UnitLength, UnitMass, UnitVelocity) number_gas_particles = 1000 gas = new_evrard_gas_sphere(number_gas_particles, convert_nbody, do_scale=True, seed=12345) sph_code = Gadget2(converter) sph_code.initialize_code() sph_code.parameters.stopping_condition_maximum_density = 10 * UnitMass / UnitLength**3 sph_code.gas_particles.add_particles(gas) self.assertIsOfOrder(max(sph_code.gas_particles.density), UnitMass / UnitLength**3) density_limit_detection = sph_code.stopping_conditions.density_limit_detection density_limit_detection.enable() sph_code.evolve_model(10.0 | units.Myr) self.assertTrue(density_limit_detection.is_set()) self.assertTrue(sph_code.model_time < 10.0 | units.Myr) print("density_limit exceeded at t =", sph_code.model_time.as_quantity_in(units.Myr)) self.assertEqual(len(density_limit_detection.particles()), 1) self.assertTrue(density_limit_detection.particles().density > 10 * UnitMass / UnitLength**3) clumps = density_limit_detection.particles().copy() sph_code.gas_particles.remove_particles(clumps) clumps_in_code = sph_code.dm_particles.add_particles(clumps) sinks = new_sink_particles(clumps_in_code,looping_over=self.looping_over) self.assertEqual(sinks.sink_radius, clumps.radius) self.assertAlmostRelativeEqual(sinks.mass, UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sinks.position, clumps.position, 10) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 1) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) self.assertEqual(set(sinks.get_attribute_names_defined_in_store()) - set(["sink_radius","lx","ly","lz"]), set(sph_code.particles.get_attribute_names_defined_in_store())) sinks.accrete(sph_code.gas_particles) self.assertAlmostRelativeEqual(sinks.mass, 3 * UnitMass / number_gas_particles, 10) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 3) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) sinks.accrete(sph_code.particles) # Nothing happens: gas already gone, and cannot accrete itself self.assertAlmostRelativeEqual(sinks.mass, 3 * UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) steps = 0 while True: sph_code.evolve_model(sph_code.model_time + (0.1 | units.Myr)) sinks.sink_radius = 4 * clumps_in_code.radius sinks.accrete(sph_code.gas_particles) steps += 1 if density_limit_detection.is_set(): break self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 7) self.assertAlmostRelativeEqual(sinks.mass, 7 * UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) self.assertTrue(density_limit_detection.is_set()) self.assertEqual(steps, 5) self.assertTrue(sph_code.model_time < 10.0 | units.Myr) print("density_limit exceeded at t =", sph_code.model_time.as_quantity_in(units.Myr)) self.assertEqual(len(density_limit_detection.particles()), 5) self.assertTrue((density_limit_detection.particles().density > 10 * UnitMass / UnitLength**3).all()) clumps = density_limit_detection.particles().copy() sph_code.gas_particles.remove_particles(clumps) clumps_in_code = sph_code.dm_particles.add_particles(clumps) sinks.add_sinks(clumps_in_code, sink_radius=0.1|units.kpc) self.assertEqual(sinks[1:].sink_radius, 0.1 | units.kpc) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 12) self.assertAlmostRelativeEqual(sinks.mass[1:], UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sinks.position[1:], clumps.position, 10) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) sinks.accrete(sph_code.gas_particles) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 66) self.assertAlmostRelativeEqual(sph_code.particles.total_mass().as_quantity_in(units.MSun), UnitMass, 10) self.assertAlmostRelativeEqual(sinks.mass, [7.0, 13.0, 15.0, 9.0, 11.0, 11.0] * UnitMass / number_gas_particles, 10)
def evolve_model(self): self.initialize_data() self.ism_code = Gadget2(self.converter, number_of_workers=self.n_core)#, debugger='gdb') self.ism_code.parameters.time_max = 1024*self.dt self.ism_code.parameters.n_smooth = 64 self.ism_code.parameters.n_smooth_tol = 2./64. self.ism_code.parameters.artificial_viscosity_alpha = 0.1 self.ism_code.parameters.epsilon_squared = (1. | units.AU)**2. self.all_particles = Particles() write_set_to_file(self.star, self.filename, "hdf5", append_to_file=False) write_set_to_file(self.all_particles, self.filename, "hdf5", append_to_file=False) self.initial_disc_particles = self.create_disc() self.all_particles.add_particles(self.initial_disc_particles) self.ism_code.gas_particles.add_particles(self.initial_disc_particles) #You can only add a sink after adding gas particles #starinsph refers to the corresponding particle set/id in the community code starinsph = self.ism_code.dm_particles.add_particles(self.star) #Use the build-in sink particle routine from amuse.ext.sink. Sink_radius needs to be defined manually otherwise the particle radius in gadget is taken, #which does not corresponding to the particle radius in the framework (since 'particles' in gadget do not have a radius, it is set to 0.01 | generic_unit_system.length #and corresponds to the gas gravitational smoothing epsilon. sink = new_sink_particles(starinsph, sink_radius= self.star.radius) self.channel_from_ismcode_to_framework = self.ism_code.gas_particles.new_channel_to(self.all_particles) time = 0. | units.yr while time <= (self.tend+self.dt/2.): print("Adding new slice of ISM...") newslice=self.make_slice() self.ism_code.gas_particles.add_particles(newslice) self.all_particles.add_particles(newslice) start = timing.time() print("=======================================================") print("Evolving to time = ", time.value_in(units.yr), " of ", self.tend.value_in(units.yr)," years...") self.ism_code.evolve_model(time) print("This took ", (timing.time() - start), " s") out_of_bounds = self.ism_code.gas_particles.select_array(lambda x,y,z:(x > self.cylinder_radius)|((z**2+y**2).sqrt() >= self.cylinder_radius), ["x","y","z"]) if len(out_of_bounds)>0: print("Removing ", len(out_of_bounds), " particles from the code because they were out of bounds") self.ism_code.gas_particles.remove_particles(out_of_bounds) self.ism_code.gas_particles.synchronize_to(self.all_particles) sink.accrete(self.ism_code.gas_particles) write_set_to_file(self.star, self.filename, "hdf5") write_set_to_file(self.all_particles, self.filename, "hdf5") time += self.dt print("=======================================================") self.ism_code.stop()
def test3(self): print "Demonstrate new_sink_particles usage (using Gadget2)" UnitLength = 1.0 | units.kpc UnitMass = 1.0e10 | units.MSun UnitVelocity = 1.0 | units.km / units.s convert_nbody = nbody_system.nbody_to_si(UnitLength, UnitMass) converter = ConvertBetweenGenericAndSiUnits(UnitLength, UnitMass, UnitVelocity) number_gas_particles = 1000 gas = new_evrard_gas_sphere(number_gas_particles, convert_nbody, do_scale=True, seed=12345) sph_code = Gadget2(converter) sph_code.initialize_code() sph_code.parameters.stopping_condition_maximum_density = 10 * UnitMass / UnitLength**3 sph_code.gas_particles.add_particles(gas) self.assertIsOfOrder(max(sph_code.gas_particles.density), UnitMass / UnitLength**3) density_limit_detection = sph_code.stopping_conditions.density_limit_detection density_limit_detection.enable() sph_code.evolve_model(10.0 | units.Myr) self.assertTrue(density_limit_detection.is_set()) self.assertTrue(sph_code.model_time < 10.0 | units.Myr) print "density_limit exceeded at t =", sph_code.model_time.as_quantity_in(units.Myr) self.assertEquals(len(density_limit_detection.particles()), 1) self.assertTrue(density_limit_detection.particles().density > 10 * UnitMass / UnitLength**3) clumps = density_limit_detection.particles().copy() sph_code.gas_particles.remove_particles(clumps) clumps_in_code = sph_code.dm_particles.add_particles(clumps) sinks = new_sink_particles(clumps_in_code,looping_over=self.looping_over) self.assertEqual(sinks.sink_radius, clumps.radius) self.assertAlmostRelativeEqual(sinks.mass, UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sinks.position, clumps.position, 10) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 1) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) self.assertEqual(set(sinks.get_attribute_names_defined_in_store()) - set(["sink_radius","lx","ly","lz"]), set(sph_code.particles.get_attribute_names_defined_in_store())) sinks.accrete(sph_code.gas_particles) self.assertAlmostRelativeEqual(sinks.mass, 3 * UnitMass / number_gas_particles, 10) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 3) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) sinks.accrete(sph_code.particles) # Nothing happens: gas already gone, and cannot accrete itself self.assertAlmostRelativeEqual(sinks.mass, 3 * UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) steps = 0 while True: sph_code.evolve_model(sph_code.model_time + (0.1 | units.Myr)) sinks.sink_radius = 4 * clumps_in_code.radius sinks.accrete(sph_code.gas_particles) steps += 1 if density_limit_detection.is_set(): break self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 7) self.assertAlmostRelativeEqual(sinks.mass, 7 * UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) self.assertTrue(density_limit_detection.is_set()) self.assertEqual(steps, 5) self.assertTrue(sph_code.model_time < 10.0 | units.Myr) print "density_limit exceeded at t =", sph_code.model_time.as_quantity_in(units.Myr) self.assertEquals(len(density_limit_detection.particles()), 5) self.assertTrue((density_limit_detection.particles().density > 10 * UnitMass / UnitLength**3).all()) clumps = density_limit_detection.particles().copy() sph_code.gas_particles.remove_particles(clumps) clumps_in_code = sph_code.dm_particles.add_particles(clumps) sinks.add_sinks(clumps_in_code, sink_radius=0.1|units.kpc) self.assertEqual(sinks[1:].sink_radius, 0.1 | units.kpc) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 12) self.assertAlmostRelativeEqual(sinks.mass[1:], UnitMass / number_gas_particles, 10) self.assertAlmostRelativeEqual(sinks.position[1:], clumps.position, 10) self.assertAlmostRelativeEqual(sph_code.particles.total_mass(), UnitMass, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), UnitMass - sinks.total_mass(), 10) sinks.accrete(sph_code.gas_particles) self.assertEqual(len(sph_code.gas_particles), number_gas_particles - 66) self.assertAlmostRelativeEqual(sph_code.particles.total_mass().as_quantity_in(units.MSun), UnitMass, 10) self.assertAlmostRelativeEqual(sinks.mass, [7.0, 13.0, 15.0, 9.0, 11.0, 11.0] * UnitMass / number_gas_particles, 10)
def evolve_model(self): self.initialize_data() self.ism_code = Gadget2(self.converter, number_of_workers=self.n_core)#, debugger='gdb') self.ism_code.parameters.time_max = 1024*self.dt self.ism_code.parameters.n_smooth = 64 self.ism_code.parameters.n_smooth_tol = 2./64. self.ism_code.parameters.artificial_viscosity_alpha = 0.1 self.ism_code.parameters.epsilon_squared = (1. | units.AU)**2. self.all_particles = Particles() write_set_to_file(self.star, self.filename, "hdf5", append_to_file=False) write_set_to_file(self.all_particles, self.filename, "hdf5", append_to_file=False) self.initial_disc_particles = self.create_disc() self.all_particles.add_particles(self.initial_disc_particles) self.ism_code.gas_particles.add_particles(self.initial_disc_particles) #You can only add a sink after adding gas particles #starinsph refers to the corresponding particle set/id in the community code starinsph = self.ism_code.dm_particles.add_particles(self.star) #Use the build-in sink particle routine from amuse.ext.sink. Sink_radius needs to be defined manually otherwise the particle radius in gadget is taken, #which does not corresponding to the particle radius in the framework (since 'particles' in gadget do not have a radius, it is set to 0.01 | generic_unit_system.length #and corresponds to the gas gravitational smoothing epsilon. sink = new_sink_particles(starinsph, sink_radius= self.star.radius) self.channel_from_ismcode_to_framework = self.ism_code.gas_particles.new_channel_to(self.all_particles) time = 0. | units.yr while time <= (self.tend+self.dt/2.): print "Adding new slice of ISM..." newslice=self.make_slice() self.ism_code.gas_particles.add_particles(newslice) self.all_particles.add_particles(newslice) start = timing.time() print "=======================================================" print "Evolving to time = ", time.value_in(units.yr), " of ", self.tend.value_in(units.yr)," years..." self.ism_code.evolve_model(time) print "This took ", (timing.time() - start), " s" out_of_bounds = self.ism_code.gas_particles.select_array(lambda x,y,z:(x > self.cylinder_radius)|((z**2+y**2).sqrt() >= self.cylinder_radius), ["x","y","z"]) if len(out_of_bounds)>0: print "Removing ", len(out_of_bounds), " particles from the code because they were out of bounds" self.ism_code.gas_particles.remove_particles(out_of_bounds) self.ism_code.gas_particles.synchronize_to(self.all_particles) sink.accrete(self.ism_code.gas_particles) write_set_to_file(self.star, self.filename, "hdf5") write_set_to_file(self.all_particles, self.filename, "hdf5") time += self.dt print "=======================================================" self.ism_code.stop()