def test8(self): random.seed(1001) print "Test 8: SI vs nbody units." converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.RSun) numpy.random.seed(1234) particles = new_plummer_model(1000, convert_nbody=converter) hop = Hop(unit_converter=converter) hop.particles.add_particles(particles) hop.calculate_densities() hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3 hop.do_hop() groups = list(hop.groups()) self.assertEquals(len(hop.particles), 1000) self.assertEquals(len(groups), 1) self.assertEquals(len(groups[0]), 511) self.assertEquals(len(hop.no_group()), 489) hop.stop() numpy.random.seed(1234) particles = new_plummer_model(1000) hop = Hop() hop.particles.add_particles(particles) hop.calculate_densities() hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3 hop.do_hop() groups = list(hop.groups()) self.assertEquals(len(hop.particles), 1000) self.assertEquals(len(groups), 1) self.assertEquals(len(groups[0]), 511) self.assertEquals(len(hop.no_group()), 489) hop.stop()
def test7(self): factory = self.gravity_code_factory() instance = self.new_instance_of_an_optional_code(factory) try: particles = new_plummer_model(100, convert_nbody = self.nbody_converter) new_particles = new_plummer_model(50, convert_nbody = self.nbody_converter) instance.particles.add_particles(particles) instance.commit_particles() self.assertEquals(len(instance.particles), 100) instance.synchronize_model() instance.particles.remove_particle(particles[40]) instance.particles.remove_particle(particles[70]) instance.particles.add_particle(new_particles[0]) print new_particles[0].key instance.recommit_particles() # test the get_mass, get_position and get_velocity functions # if they are implemented for the code, otherwise will call # get_state multiple times # todo, fi fails, need to check with inti #self.assertAlmostRelativeEqual(instance.particles[-1].mass, new_particles[0].mass) #self.assertAlmostRelativeEqual(instance.particles[-1].velocity, new_particles[0].velocity) #self.assertAlmostRelativeEqual(instance.particles[-1].position, new_particles[0].position) instance.particles.synchronize_to(particles) self.assertEquals(len(particles), 99) self.assertEquals(particles[-1], new_particles[0]) finally: instance.stop()
def test3(self): random.seed(1001) print "Third test: densest neighbors and groups." hop = HopInterface() hop.initialize_code() particles1 = new_plummer_model(10) particles2 = new_plummer_model(10) particles3 = new_plummer_model(10) particles2.position += (10, 0, 0) | nbody_system.length particles3.position += (0, 20, 0) | nbody_system.length ids1, errors = hop.new_particle( particles1.mass.value_in(nbody_system.mass), particles1.x.value_in(nbody_system.length), particles1.y.value_in(nbody_system.length), particles1.z.value_in(nbody_system.length)) ids2, errors = hop.new_particle( particles2.mass.value_in(nbody_system.mass), particles2.x.value_in(nbody_system.length), particles2.y.value_in(nbody_system.length), particles2.z.value_in(nbody_system.length)) ids3, errors = hop.new_particle( particles3.mass.value_in(nbody_system.mass), particles3.x.value_in(nbody_system.length), particles3.y.value_in(nbody_system.length), particles3.z.value_in(nbody_system.length)) hop.set_nDens(5) hop.calculate_densities() hop.do_hop() n, err = hop.get_group_id(ids1) self.assertEquals(n, 2) self.assertEquals(err, 0) n, err = hop.get_group_id(ids2) self.assertEquals(err, 0) n, err = hop.get_group_id(ids3) self.assertEquals(err, 0) n, err = hop.get_densest_particle_in_group(2) self.assertEquals(n, 7) for i in range(3): n, err = hop.get_number_of_particles_in_group(0) self.assertEquals(err, 0) self.assertEquals(n, 10) n, err = hop.get_number_of_groups() self.assertEquals(n, 3) n, err = hop.get_densest_neighbor(ids1) self.assertEquals(n, [7, 7, 12, 0, 7, 7, 7, 7, 12, 7]) hop.stop()
def test2(self): seed(1) particles=new_plummer_model(10000) instance = Agama(type="Multipole", particles=particles) result=instance.get_potential_at_point( 0.|generic_unit_system.length, 0.|generic_unit_system.length, 0.|generic_unit_system.length, 0.|generic_unit_system.length) self.assertLess(abs(result/(-16./3/3.1416| generic_unit_system.length**2/generic_unit_system.time**2) - 1), 0.04) scaleM=1234|units.MSun scaleR=5.6 |units.parsec converter=nbody_system.nbody_to_si(scaleM,scaleR) particles=new_plummer_model(20000, convert_nbody=converter) instance = Agama(converter, type="Multipole", particles=particles) x=3.|units.parsec y=4.|units.parsec z=5.|units.parsec r=(x*x+y*y+z*z)**0.5 result=instance.get_gravity_at_point(0|units.parsec, x, y, z) expected=-constants.G*scaleM/(r*r+(3*3.1416/16*scaleR)**2)**1.5*x self.assertLess(abs(result[0]/expected-1), 0.03) self.assertLess(abs(result[2]/result[0]-z/x), 0.03) instance.stop()
def test4(self): numpy.random.seed(12345) plummer = new_plummer_model(100) fastkick = self.new_fastkick_instance() fastkick.initialize_code() fastkick.particles.add_particles(plummer) points = new_plummer_model(73) potential1 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z) ax1, ay1, az1 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z) fastkick.reset() potential0 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z) ax0, ay0, az0 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z) self.assertAlmostEqual(potential0, 0 | nbody_system.potential) self.assertAlmostEqual(ax0, 0 | nbody_system.acceleration) self.assertAlmostEqual(ay0, 0 | nbody_system.acceleration) self.assertAlmostEqual(az0, 0 | nbody_system.acceleration) fastkick.reset() for p in plummer: fastkick.particles.add_particle(p) potential2 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z) ax2, ay2, az2 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z) self.assertAlmostEqual(potential1, potential2, 5) self.assertAlmostEqual(ax1, ax2, 5) self.assertAlmostEqual(ay1, ay2, 5) self.assertAlmostEqual(az1, az2, 5) fastkick.cleanup_code() fastkick.stop()
def test6(self): factory = self.gravity_code_factory() instance = self.new_instance_of_an_optional_code(factory) try: particles = new_plummer_model(100, convert_nbody = self.nbody_converter) more_particles = new_plummer_model(50, convert_nbody = self.nbody_converter) particles.radius = 0 | self.length_unit more_particles.radius = 1.0 | self.length_unit particles.move_to_center() more_particles.move_to_center() instance.particles.add_particles(particles) instance.commit_particles() self.assertEquals(len(instance.particles), 100) instance.synchronize_model() instance.particles.add_particles(more_particles) instance.recommit_particles() number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles'] self.assertEquals(len(instance.particles), 150) self.assertEquals(number_of_particles_in_module, 150) instance.synchronize_model() instance.particles.remove_particles(particles) self.assertEquals(len(instance.particles), 50) instance.recommit_particles() instance.synchronize_model() number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles'] self.assertEquals(len(instance.particles), 50) self.assertEquals(number_of_particles_in_module, 50) finally: instance.stop()
def test6(self): plummer = new_plummer_model(100) points = new_plummer_model(73) instance = self.new_fastkick_instance(number_of_workers=1) instance.particles.add_particles(plummer) potential1 = instance.get_potential_at_point(0 * points.x, points.x, points.y, points.z) ax1, ay1, az1 = instance.get_gravity_at_point(0 * points.x, points.x, points.y, points.z) instance.stop() expected_accuracy = 13 if self.mode == "cpu" else 5 number_of_workers_range = [2, 3, 4, 5] if self.mode == "cpu" else [2] for n in number_of_workers_range: instance = self.new_fastkick_instance(number_of_workers=n) instance.particles.add_particles(plummer) potential = instance.get_potential_at_point( 0 * points.x, points.x, points.y, points.z) ax, ay, az = instance.get_gravity_at_point(0 * points.x, points.x, points.y, points.z) instance.stop() self.assertAlmostEqual(potential, potential1, expected_accuracy) self.assertAlmostEqual(ax, ax1, expected_accuracy) self.assertAlmostEqual(ay, ay1, expected_accuracy) self.assertAlmostEqual(az, az1, expected_accuracy)
def test4(self): numpy.random.seed(12345) plummer = new_plummer_model(100) fastkick = self.new_fastkick_instance() fastkick.initialize_code() fastkick.particles.add_particles(plummer) points = new_plummer_model(73) potential1 = fastkick.get_potential_at_point(0 * points.x, points.x, points.y, points.z) ax1, ay1, az1 = fastkick.get_gravity_at_point(0 * points.x, points.x, points.y, points.z) fastkick.reset() potential0 = fastkick.get_potential_at_point(0 * points.x, points.x, points.y, points.z) ax0, ay0, az0 = fastkick.get_gravity_at_point(0 * points.x, points.x, points.y, points.z) self.assertAlmostEqual(potential0, 0 | nbody_system.potential) self.assertAlmostEqual(ax0, 0 | nbody_system.acceleration) self.assertAlmostEqual(ay0, 0 | nbody_system.acceleration) self.assertAlmostEqual(az0, 0 | nbody_system.acceleration) fastkick.reset() for p in plummer: fastkick.particles.add_particle(p) potential2 = fastkick.get_potential_at_point(0 * points.x, points.x, points.y, points.z) ax2, ay2, az2 = fastkick.get_gravity_at_point(0 * points.x, points.x, points.y, points.z) self.assertAlmostEqual(potential1, potential2, 5) self.assertAlmostEqual(ax1, ax2, 5) self.assertAlmostEqual(ay1, ay2, 5) self.assertAlmostEqual(az1, az2, 5) fastkick.cleanup_code() fastkick.stop()
def test9(self): print "Testing MI6 evolve_model and getters energy, plummer sphere, no SMBH" converter = nbody_system.nbody_to_si(1.0e2 | units.MSun, 1.0 | units.parsec) instance = MI6(converter, **default_options) instance.initialize_code() instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() numpy.random.seed(987654321) instance.particles.add_particles( new_plummer_model(100, convert_nbody=converter)) instance.commit_particles() kinetic_energy = instance.kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 2.12292810174e+37 | units.J, 10) self.assertAlmostRelativeEqual(potential_energy, -4.33511391248e+37 | units.J, 10) initial_total_energy = kinetic_energy + potential_energy instance.evolve_model(0.1 | nbody_system.time) kinetic_energy = instance.kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 2.13633848369e+37 | units.J, 5) self.assertAlmostRelativeEqual(potential_energy, -4.34851806763e+37 | units.J, 5) self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 5) instance.cleanup_code() instance.stop()
def test2(self): random.seed(1001) hop = HopInterface() hop.initialize_code() particles = new_plummer_model(1000) ids, errors = hop.new_particle( particles.mass.value_in(nbody_system.mass), particles.x.value_in(nbody_system.length), particles.y.value_in(nbody_system.length), particles.z.value_in(nbody_system.length)) n, err = hop.get_number_of_particles() self.assertEquals(n, 1000) self.assertEquals(err, 0) #distance_to_center = (particles.position - particles.center_of_mass()).lengths() #print distance_to_center ds = {0: 0.482308834791, 1: 0.4885137677192688, 2: 0.27442726492881775} for method in [0, 1, 2]: hop.set_nDens(7) hop.set_density_method(method) hop.calculate_densities() d, err = hop.get_density(0) self.assertAlmostRelativeEquals(d, ds[method], 5) hop.stop()
def test2(self): random.seed(1001) hop = Hop() hop.initialize_code() hop.parameters.number_of_neighbors_for_local_density = 7 hop.commit_parameters() particles = new_plummer_model(1000) hop.particles.add_particles(particles) #distance_to_center = (particles.position - particles.center_of_mass()).lengths() #print distance_to_center ds = {0: 0.482308834791, 1: 0.4885137677192688, 2: 0.27442726492881775} for method in [0, 1, 2]: hop.set_density_method(method) hop.calculate_densities() d = hop.particles[0].density self.assertAlmostRelativeEquals(d, ds[method] | nbody_system.density, 5) hop.stop()
def test13(self): particles = plummer.new_plummer_model(31) instance = Hermite(number_of_workers=1)#, debugger="xterm") instance.initialize_code() instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2 instance.particles.add_particles(particles) instance.evolve_model(0.1 | nbody_system.time) instance.synchronize_model() expected_positions = instance.particles.position instance.stop() positions_per_workers = [] for n in [2,3,4,5]: instance = Hermite(number_of_workers=n) instance.initialize_code() instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2 instance.particles.add_particles(particles) instance.evolve_model(0.1 | nbody_system.time) instance.synchronize_model() positions_per_workers.append(instance.particles.position) instance.stop() for index, n in enumerate([2,3,4,5]): self.assertAlmostEqual(expected_positions, positions_per_workers[index], 15)
def test1(self): plummer_size = 500 plummer = new_plummer_model(plummer_size) mass=plummer.mass.number radius=plummer.radius.number x=plummer.x.number y=plummer.y.number z=plummer.z.number vx=plummer.vx.number vy=plummer.vy.number vz=plummer.vz.number instance = self.new_instance_of_an_optional_code(BonsaiInterface, **default_options) self.assertEquals(0, instance.initialize_code()) self.assertEquals([0, 0], instance.get_number_of_particles().values()) ids, errors = instance.new_particle(mass,x,y,z,vx,vy,vz,radius) self.assertEquals(0, errors) self.assertEquals(range(plummer_size), ids) self.assertEquals(0, instance.commit_particles()) self.assertEquals([500, 0], instance.get_number_of_particles().values()) masses, errors = instance.get_mass(range(500)) self.assertEquals(0, errors) self.assertAlmostEquals(0.002, masses) masses,xs,ys,zs,vxs,vys,vzs,radii, errors = instance.get_state(range(500)) self.assertEquals(0, errors) self.assertAlmostRelativeEquals(xs, x, 6) self.assertEquals(0, instance.evolve_model(0.00001)) energy_total_init = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"] self.assertEquals(0, instance.evolve_model(1)) energy_total_final = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"] self.assertAlmostRelativeEqual(energy_total_init, energy_total_final, 2) instance.stop()
def test6(self): print "Testing Bonsai states" plummer = new_plummer_model(500) print "First do everything manually:" instance = self.new_instance_of_an_optional_code(Bonsai, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.initialize_code() self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.commit_parameters() self.assertEquals(instance.get_name_of_current_state(), 'EDIT') instance.particles.add_particles(plummer) instance.commit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') mass = instance.particles[0].mass instance.evolve_model(0.1 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') instance.cleanup_code() self.assertEquals(instance.get_name_of_current_state(), 'END') instance.stop() print ("initialize_code(), commit_parameters(), commit_particles(), and cleanup_code() should be called " + "automatically before editing parameters, new_particle(), get_xx(), and stop():") instance = self.new_instance_of_an_optional_code(Bonsai, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') timestep = instance.parameters.timestep self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.particles.add_particles(plummer) self.assertEquals(instance.get_name_of_current_state(), 'EDIT') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.1 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') instance.stop() self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test2(self): random.seed(1001) hop = HopInterface() hop.initialize_code() particles = new_plummer_model(1000) ids, errors = hop.new_particle( particles.mass.value_in(nbody_system.mass), particles.x.value_in(nbody_system.length), particles.y.value_in(nbody_system.length), particles.z.value_in(nbody_system.length) ) n, err = hop.get_number_of_particles() self.assertEquals(n, 1000) self.assertEquals(err, 0) #distance_to_center = (particles.position - particles.center_of_mass()).lengths() #print distance_to_center ds = {0: 0.482308834791, 1:0.4885137677192688, 2:0.27442726492881775} for method in [0,1,2]: hop.set_nDens(7) hop.set_density_method(method) hop.calculate_densities() d, err = hop.get_density(0) self.assertAlmostRelativeEquals(d,ds[method], 5) hop.stop()
def test5(self): print "Testing FastKick states" plummer = new_plummer_model(100) print "First do everything manually:" instance = self.new_fastkick_instance() self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.initialize_code() self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.commit_parameters() self.assertEquals(instance.get_name_of_current_state(), 'EDIT') instance.particles.add_particles(plummer) instance.commit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.cleanup_code() self.assertEquals(instance.get_name_of_current_state(), 'END') instance.stop() print "commit_parameters(), (re)commit_particles(), and cleanup_code() should be called " \ "automatically before new_xx_particle(), get_xx(), and stop():" instance = self.new_fastkick_instance() self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') eps = instance.parameters.epsilon_squared self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.particles.add_particles(plummer[:-1]) self.assertEquals(instance.get_name_of_current_state(), 'EDIT') acc = instance.get_gravity_at_point(0*plummer[-1].x, plummer[-1].x, plummer[-1].y, plummer[-1].z) self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.add_particle(plummer[-1]) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') acc = instance.get_gravity_at_point(0*plummer[-1].x, plummer[-1].x, plummer[-1].y, plummer[-1].z) self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.stop() self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test3(self): remote=RemoteCodeInterface() var=new_plummer_model(100) remote.assign("var",var) var_=remote.evaluate("var.mass") self.assertEqual(var_,var.mass)
def test_small_plummer_model(self): particles = plummer.new_plummer_model(31) instance = Petar(number_of_workers=1) # , debugger="xterm") instance.initialize_code() instance.particles.add_particles(particles) instance.evolve_model(0.1 | nbody_system.time) instance.synchronize_model() expected_positions = instance.particles.position instance.stop() positions_per_workers = [] for n in [2, 3, 4, 5]: instance = Petar(number_of_workers=n) instance.initialize_code() instance.particles.add_particles(particles) instance.evolve_model(0.1 | nbody_system.time) instance.synchronize_model() positions_per_workers.append(instance.particles.position) instance.stop() for index, n in enumerate([2, 3, 4, 5]): self.assertAlmostEqual(expected_positions, positions_per_workers[index], 15)
def test5(self): print "CalculateFieldForParticles get_potential_at_point, with individual softening" epsilon = 0.5 | units.parsec convert = nbody_system.nbody_to_si(1.0e5 | units.MSun, 1.0 | units.parsec) numpy.random.seed(12345) stars = new_plummer_model(100, convert_nbody=convert) stars.radius = epsilon * numpy.random.uniform(low=0.4, high=3.0, size=len(stars)) cluster = ExampleGravityCodeInterface(softening_mode="individual") cluster.particles.add_particles(stars) instance = bridge.CalculateFieldForParticles(particles=stars, softening_mode="individual") zeros = numpy.zeros(9) | units.parsec pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec self.assertAlmostRelativeEqual( instance.get_potential_at_point(zeros, pos_range, zeros, zeros), cluster.get_potential_at_point(zeros, pos_range, zeros, zeros), ) for a_calculate_field, a_code in zip( instance.get_gravity_at_point(zeros, pos_range, zeros, zeros), cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros), ): self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def test10(self): instance = PhiGRAPE(**default_test_options) instance.initialize_code() instance.parameters.set_defaults() stars = new_plummer_model(100) stars.radius = 0 | nbody_system.length instance.particles.add_particles(stars) channel = stars.new_channel_to(instance.particles) instance.evolve_model(0.001 | nbody_system.time) e0 = instance.kinetic_energy + instance.potential_energy stars.mass *= 0.9 channel.copy() instance.synchronize_model() e1 = instance.kinetic_energy + instance.potential_energy delta_e = e1 - e0 self.assertTrue(e1 != e0) instance.stop()
def test4(self): print "CalculateFieldForParticles get_potential_at_point, with softening" epsilon = 0.5 | units.parsec convert = nbody_system.nbody_to_si(1.0e5 | units.MSun, 1.0 | units.parsec) numpy.random.seed(12345) stars = new_plummer_model(100, convert_nbody=convert) cluster = ExampleGravityCodeInterface() cluster.parameters.epsilon_squared = epsilon ** 2 cluster.particles.add_particles(stars) instance = bridge.CalculateFieldForParticles(particles=stars) instance.smoothing_length_squared = epsilon ** 2 zeros = numpy.zeros(9) | units.parsec pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec self.assertAlmostRelativeEqual( instance.get_potential_at_point(zeros, pos_range, zeros, zeros), cluster.get_potential_at_point(zeros, pos_range, zeros, zeros), ) for a_calculate_field, a_code in zip( instance.get_gravity_at_point(zeros, pos_range, zeros, zeros), cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros), ): self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def test22(self): particles = new_plummer_model(200) particles.scale_to_standard() try: instance = ph4(mode="gpu") except: self.skip("gpu mode is not available") instance.initialize_code() instance.parameters.epsilon_squared = 0.00000 | nbody_system.length ** 2 instance.particles.add_particles(particles) x = numpy.arange(-1, 1, 0.1) | nbody_system.length zero = numpy.zeros(len(x)) | nbody_system.length gpu_potential = instance.get_potential_at_point(zero, x, zero, zero) instance.stop() instance = ph4() instance.initialize_code() instance.parameters.epsilon_squared = 0.00000 | nbody_system.length ** 2 instance.particles.add_particles(particles) nogpu_potential = instance.get_potential_at_point(zero, x, zero, zero) self.assertAlmostRelativeEquals(nogpu_potential, gpu_potential, 5) instance.stop()
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 test13(self): particles = plummer.new_plummer_model(31) instance = self.new_instance_of_an_optional_code(Hacs64, number_of_workers=1, **default_options) instance.initialize_code() instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2 instance.particles.add_particles(particles) instance.evolve_model(0.1 | nbody_system.time) instance.synchronize_model() expected_positions = instance.particles.position instance.stop() positions_per_workers = [] for n in [2, 3, 4, 5]: instance = self.new_instance_of_an_optional_code( Hacs64, number_of_workers=n, **default_options) instance.initialize_code() instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2 instance.particles.add_particles(particles) instance.evolve_model(0.1 | nbody_system.time) instance.synchronize_model() positions_per_workers.append(instance.particles.position) instance.stop() for index, n in enumerate([2, 3, 4, 5]): self.assertAlmostEqual(expected_positions, positions_per_workers[index], 15)
def test7(self): print "Testing Pikachu states" stars = new_plummer_model(100) black_hole = Particle() black_hole.mass = 1.0 | nbody_system.mass black_hole.radius = 0.0 | nbody_system.length black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed print "First do everything manually:" instance = self.new_instance_of_an_optional_code( Pikachu, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.initialize_code() self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') #~ instance.parameters.rcut_out_star_star = 1.0 | nbody_system.length instance.parameters.timestep = 0.001 | nbody_system.time instance.commit_parameters() self.assertEquals(instance.get_name_of_current_state(), 'EDIT') instance.particles.add_particles(stars) instance.commit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') instance.recommit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') instance.synchronize_model() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.cleanup_code() self.assertEquals(instance.get_name_of_current_state(), 'END') instance.stop() print "initialize_code(), commit_parameters(), (re)commit_particles(), " \ "synchronize_model(), and cleanup_code() should be called " \ "automatically before editing parameters, new_particle(), get_xx(), and stop():" instance = self.new_instance_of_an_optional_code( Pikachu, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.parameters.timestep = 0.001 | nbody_system.time self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.particles.add_particles(stars) self.assertEquals(instance.get_name_of_current_state(), 'EDIT') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.stop() self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test_kepler(N=10000, tend=1.| units.yr,method=0): numpy.random.seed(12345) conv=nbody_system.nbody_to_si(2.| units.MSun, 5.|units.AU) comets=new_plummer_model(N,conv) sun=Particle(mass=1.|units.MSun) sun.position=[0,0,0]|units.AU sun.velocity=[0,0,0]|units.kms comets.mass*=0. code=Kepler(conv,redirection="none") code.set_method(method) code.central_particle.add_particle(sun) code.orbiters.add_particles(comets) a0,eps0=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz) # print code.orbiters.x[0] print orbital_elements_from_binary(code.particles[0:2],constants.G) t1=time.time() code.evolve_model(tend) t2=time.time() print orbital_elements_from_binary(code.particles[0:2],constants.G) # print code.orbiters.x[0] a,eps=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz) da=abs((a-a0)/a0) deps=abs(eps-eps0)/eps0 dev=numpy.where(da > 0.00001)[0] print len(dev) print a0[dev].value_in(units.AU) print eps0[dev] # pyplot.plot(a0[dev].value_in(units.AU),eps0[dev],"ro") # pyplot.plot(a[dev].value_in(units.AU),eps[dev],"g+") print "max da,deps:",da.max(), deps.max() print "time:",t2-t1 # pyplot.show() return t2-t1,da.max(),deps.max()
def test9(self): print "Testing MI6 evolve_model and getters energy, plummer sphere, no SMBH" converter = nbody_system.nbody_to_si(1.0e2 | units.MSun, 1.0 | units.parsec) instance = MI6(converter, **default_options) instance.initialize_code() instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() numpy.random.seed(987654321) instance.particles.add_particles(new_plummer_model(100, convert_nbody=converter)) instance.commit_particles() kinetic_energy = instance.kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 2.12292810174e+37 | units.J, 10) self.assertAlmostRelativeEqual(potential_energy, -4.33511391248e+37 | units.J, 10) initial_total_energy = kinetic_energy + potential_energy instance.evolve_model(0.1 | nbody_system.time) kinetic_energy = instance.kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 2.13633848369e+37 | units.J, 5) self.assertAlmostRelativeEqual(potential_energy, -4.34851806763e+37 | units.J, 5) self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 5) instance.cleanup_code() instance.stop()
def test09(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura evolve_model and getters energy, plummer sphere, no SMBH" converter = nbody_system.nbody_to_si(1.0e2 | units.MSun, 1.0 | units.parsec) instance = Sakura(converter) # instance.parameters.timestep_parameter = 1.0/256 instance.initialize_code() # instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() numpy.random.seed(987654321) instance.particles.add_particles(new_plummer_model(100, convert_nbody=converter)) instance.commit_particles() kinetic_energy = instance.kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 2.12292810174e37 | units.J, 10) self.assertAlmostRelativeEqual(potential_energy, -4.33511391248e37 | units.J, 10) initial_total_energy = kinetic_energy + potential_energy instance.evolve_model(0.1 | nbody_system.time) kinetic_energy = instance.kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 2.1362368884e37 | units.J, 4) self.assertAlmostRelativeEqual(potential_energy, -4.34842269914e37 | units.J, 4) self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 4) instance.cleanup_code() instance.stop()
def test10b(self): instance = ph4(number_of_workers=4) instance.initialize_code() instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2 instance.parameters.timestep_parameter = 0.01 stars = new_plummer_model(100) instance.particles.add_particles(stars) channel = stars.new_channel_to(instance.particles) instance.evolve_model(0.001 | nbody_system.time) e0 = instance.kinetic_energy + instance.potential_energy stars.mass *= 0.9 channel.copy() instance.synchronize_model() e1 = instance.kinetic_energy + instance.potential_energy instance.cleanup_code() instance.stop() delta_e = e1 - e0 self.assertTrue(e1 != e0)
def test5(self): print "Test error codes" unit_converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) particles = new_plummer_model(200, convert_nbody=unit_converter) hop = Hop(unit_converter=unit_converter) #, redirection="none") hop.parameters.number_of_neighbors_for_local_density = 100 hop.particles.add_particles(particles[:99]) self.assertRaises( AmuseException, hop.calculate_densities, expected_message= "Error when calling 'calculate_densities' of a 'Hop', errorcode is -5, error is 'Too few particles.'" ) hop.particles.add_particles(particles[99:101]) hop.calculate_densities() hop.parameters.number_of_neighbors_for_hop = 200 self.assertRaises( AmuseException, hop.calculate_densities, expected_message= "Error when calling 'calculate_densities' of a 'Hop', errorcode is -5, error is 'Too few particles.'" ) hop.particles.add_particles(particles[101:]) hop.calculate_densities() self.assertRaises( AmuseException, hop.get_mass, 200, expected_message= "Error when calling 'get_mass' of a 'Hop', errorcode is -3, error is 'A particle with the given index was not found.'" ) hop.stop()
def test_run(N=4, tend=1. | nbody_system.time, dt=0.125 | nbody_system.time, parameters={}): numpy.random.seed(1233231) mp = Yaravi() for key in parameters: setattr(mp.parameters, key, parameters[key]) print mp.parameters plum = new_plummer_model(N, do_scale=True) mp.particles.add_particles(plum) t1 = time.time() while mp.model_time < tend - dt / 2: tnext = mp.model_time + dt if mp.model_time + dt >= tend - dt / 2: tnext = tend mp.evolve_model(tnext) t2 = time.time() print t2 - t1, (tend - mp.model_time).number return mp.particles.copy()
def test19(self): print("Testing ph4 properties") particles = new_plummer_model(1000, do_scale=True) particles.position += [1, 2, 3] | nbody_system.length cluster_velocity = [4, 5, 6] | nbody_system.speed particles.velocity += cluster_velocity external_kinetic_energy = (0.5 | nbody_system.mass) * cluster_velocity.length_squared() instance = ph4() instance.particles.add_particles(particles) kinetic_energy = instance.kinetic_energy - external_kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 0.25 | nbody_system.energy, 10) self.assertAlmostRelativeEqual(potential_energy, -0.5 | nbody_system.energy, 10) self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 10) self.assertAlmostRelativeEqual(instance.center_of_mass_position, [1, 2, 3] | nbody_system.length, 10) self.assertAlmostRelativeEqual(instance.center_of_mass_velocity, [4, 5, 6] | nbody_system.speed, 10) initial_total_energy = kinetic_energy + potential_energy instance.evolve_model(0.1 | nbody_system.time) self.assertAlmostRelativeEqual(instance.model_time, 0.1 | nbody_system.time, 3) kinetic_energy = instance.kinetic_energy - external_kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy+potential_energy, -0.25 | nbody_system.energy, 3) self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 3) self.assertAlmostRelativeEqual(instance.center_of_mass_position, [1.4, 2.5, 3.6] | nbody_system.length, 3) self.assertAlmostRelativeEqual(instance.center_of_mass_velocity, [4, 5, 6] | nbody_system.speed, 3) instance.cleanup_code() instance.stop()
def test09(self): print "Test add_spin particle attribute, to add rigid body rotation" numpy.random.seed(123456) particles = new_plummer_model(1000) kinetic_energy0 = particles.kinetic_energy() potential_energy0 = particles.potential_energy(G=nbody_system.G) particles.position += [3, 0, 2] | nbody_system.length particles.velocity += [1, 10, 100] | nbody_system.speed particles.add_spin(3.0 | nbody_system.time**-1) self.assertAlmostRelativeEquals(particles.center_of_mass(), [3, 0, 2] | nbody_system.length, 12) self.assertAlmostRelativeEquals(particles.potential_energy(G=nbody_system.G), potential_energy0, 12) self.assertAlmostRelativeEquals(particles.center_of_mass_velocity(), [1, 10, 100] | nbody_system.speed, 12) r = particles.position - particles.center_of_mass() v = particles.velocity - particles.center_of_mass_velocity() spin_direction = (r).cross(v).mean(axis=0) spin_direction /= spin_direction.length() R = r - r*spin_direction omega = ((R).cross(v) / R.lengths_squared().reshape((-1,1))).mean(axis=0).length() self.assertAlmostEquals(spin_direction, [0, 0, 1.0], 1) self.assertAlmostEquals(omega, 3.0 | nbody_system.time**-1, 1) particles.add_spin([1.0, 0, -3.0] | nbody_system.time**-1) v = particles.velocity - particles.center_of_mass_velocity() spin_direction = (r).cross(v).mean(axis=0) spin_direction /= spin_direction.length() R = r - r*spin_direction omega = ((R).cross(v) / R.lengths_squared().reshape((-1,1))).mean(axis=0).length() self.assertAlmostEquals(omega, 1.0 | nbody_system.time**-1, 1)
def __init__(self, name, Mtot=(1e15 | units.MSun), Rvir=(500 | units.kpc)): self.name = name self.converter = nbody_system.nbody_to_si(Mtot, Rvir) self.number_of_dm_particles = 1e2 self.number_of_gas_particles = 1e3 # Set up numerical smoothing fractions self.dm_smoothing_fraction = 0.001 self.gas_smoothing_fraction = 0.05 self.dm_epsilon = self.dm_smoothing_fraction * Rvir self.gas_epsilon = self.gas_smoothing_fraction * Rvir # Setup up gas and dark matter fractions and gas/dm mass self.gas_fraction = 0.1 self.dm_fraction = 1.0 - self.gas_fraction self.dm_mass = self.dm_fraction * Mtot self.gas_mass = self.gas_fraction * Mtot # Set up dark matter particles # TODO: probably not use Plummer sphere self.dm = new_plummer_model(self.number_of_dm_particles, convert_nbody=self.converter) self.dm.radius = self.dm_epsilon self.dm.mass = (1.0 / self.number_of_dm_particles) * self.dm_mass self.dm.move_to_center() # Set up virialized gas sphere of N gas particles, Plummer sphere # TODO: probably not use Plummer sphere self.gas = new_plummer_gas_model(self.number_of_gas_particles, convert_nbody=self.converter) self.gas.h_smooth = self.gas_epsilon self.gas.move_to_center() self.gas.mass = (1.0 / self.number_of_gas_particles) * self.gas_mass print "Created ", str(self)
def test22(self): particles = new_plummer_model(200) particles.scale_to_standard() try: instance = ph4(mode="gpu") except: self.skip("gpu mode is not available") instance.initialize_code() instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2 instance.particles.add_particles(particles) x = numpy.arange(-1,1,0.1) | nbody_system.length zero = numpy.zeros(len(x)) | nbody_system.length gpu_potential = instance.get_potential_at_point(zero, x , zero, zero) instance.stop() instance = ph4() instance.initialize_code() instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2 instance.particles.add_particles(particles) nogpu_potential = instance.get_potential_at_point(zero, x , zero, zero) self.assertAlmostRelativeEquals(nogpu_potential, gpu_potential, 5) instance.stop()
def test5(self): print "CalculateFieldForParticles get_potential_at_point, with individual softening" epsilon = 0.5 | units.parsec convert = nbody_system.nbody_to_si(1.e5 | units.MSun, 1.0 | units.parsec) numpy.random.seed(12345) stars = new_plummer_model(100, convert_nbody=convert) stars.radius = epsilon * numpy.random.uniform( low=0.4, high=3.0, size=len(stars)) cluster = ExampleGravityCodeInterface(softening_mode="individual") cluster.particles.add_particles(stars) instance = bridge.CalculateFieldForParticles( particles=stars, softening_mode="individual") zeros = numpy.zeros(9) | units.parsec pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec self.assertAlmostRelativeEqual( instance.get_potential_at_point(zeros, pos_range, zeros, zeros), cluster.get_potential_at_point(zeros, pos_range, zeros, zeros)) for a_calculate_field, a_code in zip( instance.get_gravity_at_point(zeros, pos_range, zeros, zeros), cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros)): self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def test5(self): instance = self.new_instance_of_an_optional_code(HiGPUs) instance.initialize_code() instance.parameters.eta6 = 0.01 instance.commit_parameters() stars = new_plummer_model(100) instance.particles.add_particles(stars) instance.commit_particles() instance.evolve_model(0.001 | nbody_system.time) e0 = instance.get_kinetic_energy() + instance.get_potential_energy() stars.mass *= 0.9 instance.synchronize_model() e1 = instance.get_kinetic_energy() + instance.get_potential_energy() instance.cleanup_code() instance.stop() delta_e = e1 - e0 self.assertTrue(e1 != e0)
def test3(self): print "Bridge potential energy with radius as softening length" convert = nbody_system.nbody_to_si(1.e5 | units.MSun, 1.0 | units.parsec) epsilon = 0.1 | units.parsec test_class = ExampleGravityCodeInterface numpy.random.seed(12345) stars = new_plummer_model(100, convert_nbody=convert) stars.radius = epsilon cluster = test_class() cluster.parameters.epsilon_squared = epsilon**2 cluster.particles.add_particles(stars) first_half = stars.select_array(lambda x: (x > 0 | units.m), ['x']) second_half = stars - first_half cluster1 = system_from_particles(test_class, dict(), first_half, epsilon) cluster2 = system_from_particles(test_class, dict(), second_half, epsilon) bridgesys = bridge.Bridge() bridgesys.add_system(cluster1, (cluster2, ), radius_is_eps=True) bridgesys.add_system(cluster2, (cluster1, )) self.assertAlmostRelativeEqual(cluster.potential_energy, bridgesys.potential_energy) self.assertAlmostRelativeEqual(cluster.kinetic_energy, bridgesys.kinetic_energy)
def test3(self): print "CalculateFieldForParticles get_potential_at_point, no softening" epsilon = 0 | units.m convert = nbody_system.nbody_to_si(1.e5 | units.MSun, 1.0 | units.parsec) numpy.random.seed(12345) stars = new_plummer_model(100, convert_nbody=convert) cluster = ExampleGravityCodeInterface() cluster.parameters.epsilon_squared = epsilon**2 cluster.particles.add_particles(stars) instance = bridge.CalculateFieldForParticles(particles=stars) instance.smoothing_length_squared = epsilon**2 zeros = numpy.zeros(9) | units.parsec pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec self.assertAlmostRelativeEqual( instance.get_potential_at_point(zeros, pos_range, zeros, zeros), cluster.get_potential_at_point(zeros, pos_range, zeros, zeros)) for a_calculate_field, a_code in zip( instance.get_gravity_at_point(zeros, pos_range, zeros, zeros), cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros)): self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def simulate_small_cluster(number_of_stars=1000, end_time=40 | nbody_system.time, number_of_workers=1): particles = new_plummer_model(number_of_stars) particles.scale_to_standard() gravity = Hermite(number_of_workers=number_of_workers) gravity.parameters.epsilon_squared = 0.15 | nbody_system.length**2 gravity.particles.add_particles(particles) from_gravity_to_model = gravity.particles.new_channel_to(particles) time = 0.0 * end_time total_energy_at_t0 = gravity.kinetic_energy + gravity.potential_energy positions_at_different_times = [] positions_at_different_times.append(particles.position) times = [] times.append(time) print("evolving the model until t = " + str(end_time)) while time < end_time: time += end_time / 3.0 gravity.evolve_model(time) from_gravity_to_model.copy() positions_at_different_times.append(particles.position) times.append(time) print_log(time, gravity, particles, total_energy_at_t0) gravity.stop() return times, positions_at_different_times
def test15(self): particles = plummer.new_plummer_model(512) expected_positions = None for mode in ["cpu", "openmp", "opencl"]: try: instance = Huayno(mode=mode, number_of_workers=1) #, debugger="xterm") except: print("Running huayno with mode=", mode, " was unsuccessful.") continue else: print("Running huayno with mode=", mode, "... ") instance.initialize_code() instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2 instance.particles.add_particles(particles) instance.evolve_model(0.2 | nbody_system.time) instance.synchronize_model() if expected_positions is None: expected_positions = instance.particles.position else: self.assertAlmostRelativeEquals(expected_positions, instance.particles.position, 8) instance.stop()
def test19(self): print "Testing ph4 properties" particles = new_plummer_model(1000, do_scale=True) particles.position += [1, 2, 3] | nbody_system.length cluster_velocity = [4, 5, 6] | nbody_system.speed particles.velocity += cluster_velocity external_kinetic_energy = (0.5 | nbody_system.mass) * cluster_velocity.length_squared() instance = ph4() instance.particles.add_particles(particles) kinetic_energy = instance.kinetic_energy - external_kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy, 0.25 | nbody_system.energy, 10) self.assertAlmostRelativeEqual(potential_energy, -0.5 | nbody_system.energy, 10) self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 10) self.assertAlmostRelativeEqual(instance.center_of_mass_position, [1, 2, 3] | nbody_system.length, 10) self.assertAlmostRelativeEqual(instance.center_of_mass_velocity, [4, 5, 6] | nbody_system.speed, 10) initial_total_energy = kinetic_energy + potential_energy instance.evolve_model(0.1 | nbody_system.time) self.assertAlmostRelativeEqual(instance.model_time, 0.1 | nbody_system.time, 3) kinetic_energy = instance.kinetic_energy - external_kinetic_energy potential_energy = instance.potential_energy self.assertAlmostRelativeEqual(kinetic_energy + potential_energy, -0.25 | nbody_system.energy, 3) self.assertAlmostRelativeEqual(instance.total_mass, 1.0 | nbody_system.mass, 3) self.assertAlmostRelativeEqual(instance.center_of_mass_position, [1.4, 2.5, 3.6] | nbody_system.length, 3) self.assertAlmostRelativeEqual(instance.center_of_mass_velocity, [4, 5, 6] | nbody_system.speed, 3) instance.cleanup_code() instance.stop()
def test10(self): instance = ph4() instance.initialize_code() instance.parameters.epsilon_squared = 0.0 | nbody_system.length ** 2 instance.parameters.timestep_parameter = 0.01 stars = new_plummer_model(100) instance.particles.add_particles(stars) channel = stars.new_channel_to(instance.particles) instance.evolve_model(0.001 | nbody_system.time) e0 = instance.kinetic_energy + instance.potential_energy stars.mass *= 0.9 channel.copy() instance.synchronize_model() e1 = instance.kinetic_energy + instance.potential_energy instance.cleanup_code() instance.stop() delta_e = e1 - e0 self.assertTrue(e1 != e0)
def test4(self): stars = new_plummer_model(2, do_scale = True) self.assertAlmostEqual(stars.kinetic_energy(), 0.25 | nbody_system.energy) self.assertAlmostEqual(stars.potential_energy(G=nbody_system.G), -0.50 | nbody_system.energy) self.assertAlmostEqual(stars.center_of_mass(), [0,0,0] | nbody_system.length) self.assertAlmostEqual(stars.center_of_mass_velocity(), [0,0,0] | nbody_system.speed) self.assertAlmostEqual(stars.mass.sum(), 1.00 | nbody_system.mass) self.assertAlmostEqual(stars.virial_radius(), 1.00 | nbody_system.length)
def create_stars(number_of_stars, size): masses = new_salpeter_mass_distribution(number_of_stars, mass_min = 2|units.MSun) converter = nbody_system.nbody_to_si(masses.sum(), size) stars = new_plummer_model(number_of_stars, convert_nbody=converter) stars.mass = masses stars.zams_mass = masses return stars, converter
def test28(self): particles = plummer.new_plummer_model(31) instance = Huayno() instance.particles.add_particles(particles) self.assertAlmostEqual(particles.total_mass(),instance.total_mass) self.assertAlmostEqual(particles.center_of_mass(),instance.center_of_mass_position) self.assertAlmostEqual(particles.center_of_mass_velocity(),instance.center_of_mass_velocity)
def test23(self): print "testing removing and adding particles repeatedly" N=1100 p1=plummer.new_plummer_model(N) p2=plummer.new_plummer_model(N) h1=Huayno() h1.particles.add_particles(p1[:N/2]) h1.particles.add_particles(p2[-N/2:]) h2=Huayno() h2.particles.add_particles(p1) h2.particles.remove_particles(p1[N/2:]) h2.particles.add_particles(p2) h2.particles.remove_particles(p2[:-N/2]) self.assertEqual(len(h1.particles),len(h2.particles)) self.assertAlmostEqual(h1.kinetic_energy,h2.kinetic_energy,15) self.assertAlmostEqual(h1.potential_energy,h2.potential_energy,15)
def test16(self): print "Testing ph4 states" stars = new_plummer_model(100) black_hole = datamodel.Particle() black_hole.mass = 1.0 | nbody_system.mass black_hole.radius = 0.0 | nbody_system.length black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed print "First do everything manually:" instance = ph4() self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.initialize_code() self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2 instance.parameters.timestep_parameter = 0.01 instance.commit_parameters() self.assertEquals(instance.get_name_of_current_state(), 'EDIT') instance.particles.add_particles(stars) instance.commit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') instance.recommit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') instance.synchronize_model() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.cleanup_code() self.assertEquals(instance.get_name_of_current_state(), 'END') instance.stop() print "initialize_code(), commit_parameters(), (re)commit_particles(), " \ "synchronize_model(), and cleanup_code() should be called " \ "automatically before editing parameters, new_particle(), get_xx(), and stop():" instance = ph4() self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2 instance.parameters.timestep_parameter = 0.01 self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.particles.add_particles(stars) self.assertEquals(instance.get_name_of_current_state(), 'EDIT') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.stop() self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def integrate_system(N, t_end, seed=None): gravity = ph4() gravity.initialize_code() gravity.parameters.set_defaults() if seed is not None: numpy.random.seed(seed) stars = new_plummer_model(N) stars.mass = 1./N | nbody_system.mass stars.scale_to_standard(smoothing_length_squared = gravity.parameters.epsilon_squared) id = numpy.arange(N) stars.id = id+1 # Set dynamical radii for encounters. stars.radius = 0.5*stars.mass.number | nbody_system.length gravity.particles.add_particles(stars) stopping_condition = gravity.stopping_conditions.collision_detection stopping_condition.enable() init_smalln() kep = Kepler(unit_converter=None) kep.initialize_code() multiples_code = multiples.Multiples(gravity, new_smalln, kep) multiples_code.neighbor_perturbation_limit = 0.05 multiples_code.global_debug = 1 # global_debug = 0: no output from multiples # 1: minimal output # 2: debugging output # 3: even more output print '' print 'multiples_code.neighbor_veto =', \ multiples_code.neighbor_veto print 'multiples_code.neighbor_perturbation_limit =', \ multiples_code.neighbor_perturbation_limit print 'multiples_code.retain_binary_apocenter =', \ multiples_code.retain_binary_apocenter print 'multiples_code.wide_perturbation_limit =', \ multiples_code.wide_perturbation_limit # Advance the system. E0 = print_diagnostics(multiples_code) multiples_code.evolve_model(t_end) print_diagnostics(multiples_code, E0) gravity.stop() kep.stop() stop_smalln()
def test7(self): print "Testing Pikachu states" stars = new_plummer_model(100) black_hole = Particle() black_hole.mass = 1.0 | nbody_system.mass black_hole.radius = 0.0 | nbody_system.length black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed print "First do everything manually:" instance = self.new_instance_of_an_optional_code(Pikachu, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.initialize_code() self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') #~ instance.parameters.rcut_out_star_star = 1.0 | nbody_system.length instance.parameters.timestep = 0.001 | nbody_system.time instance.commit_parameters() self.assertEquals(instance.get_name_of_current_state(), 'EDIT') instance.particles.add_particles(stars) instance.commit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') instance.recommit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') instance.synchronize_model() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.cleanup_code() self.assertEquals(instance.get_name_of_current_state(), 'END') instance.stop() print "initialize_code(), commit_parameters(), (re)commit_particles(), " \ "synchronize_model(), and cleanup_code() should be called " \ "automatically before editing parameters, new_particle(), get_xx(), and stop():" instance = self.new_instance_of_an_optional_code(Pikachu, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.parameters.timestep = 0.001 | nbody_system.time self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.particles.add_particles(stars) self.assertEquals(instance.get_name_of_current_state(), 'EDIT') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.stop() self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test3(self): print "Testing Bonsai, N-body units" instance = self.new_instance_of_an_optional_code(Bonsai, **default_options) instance.initialize_code() plummer = new_plummer_model(500) instance.particles.add_particles(plummer) self.assertAlmostEquals(instance.particles.mass, 0.002 | nbody_system.mass) instance.evolve_model(1.0 | nbody_system.time) self.assertAlmostEquals(instance.model_time, 1.0 | nbody_system.time) instance.stop()
def test4(self): print "Testing Bonsai, SI units" convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun, 1.0 | units.parsec) instance = self.new_instance_of_an_optional_code(Bonsai, convert_nbody, **default_options) instance.initialize_code() plummer = new_plummer_model(500, convert_nbody = convert_nbody) instance.particles.add_particles(plummer) instance.commit_particles() instance.evolve_model(1 | nbody_system.time) instance.stop()