def xtest07(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing effect of Sakura parameter epsilon_squared" converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) particles = self.new_sun_earth_system() particles.rotate(0.0, 0.0, -math.pi / 4) particles.move_to_center() tan_initial_direction = particles[1].vy / particles[1].vx self.assertAlmostEquals(tan_initial_direction, math.tan(math.pi / 4)) tan_final_direction = [] for log_eps2 in range(-9, 10, 2): instance = Sakura(converter) instance.initialize_code() instance.parameters.epsilon_squared = 10.0 ** log_eps2 | units.AU ** 2 # instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() instance.particles.add_particles(particles) instance.commit_particles() instance.evolve_model(0.25 | units.yr) tan_final_direction.append(instance.particles[1].velocity[1] / instance.particles[1].velocity[0]) instance.cleanup_code() instance.stop() # Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees self.assertAlmostEquals(tan_final_direction[0], math.tan(3 * math.pi / 4.0), 2) # Large values of epsilon_squared should result in ~ no interaction self.assertAlmostEquals(tan_final_direction[-1], tan_initial_direction, 2) # Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2 delta = [abs(tan_final_direction[i + 1] - tan_final_direction[i]) for i in range(len(tan_final_direction) - 1)] self.assertEquals(delta[len(tan_final_direction) / 2 - 1], max(delta))
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 xtest10(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura collision_detection" particles = Particles(7) particles.mass = 0.00000001 | nbody_system.mass particles.radius = 0.01 | nbody_system.length particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length particles.y = 0 | nbody_system.length particles.z = 0 | nbody_system.length particles.velocity = [[2, 0, 0], [-2, 0, 0]] * 3 + [[-4, 0, 0]] | nbody_system.speed instance = Sakura() instance.initialize_code() instance.parameters.set_defaults() instance.particles.add_particles(particles) collisions = instance.stopping_conditions.collision_detection collisions.enable() instance.evolve_model(1.0 | nbody_system.time) self.assertTrue(collisions.is_set()) self.assertTrue(instance.model_time < 0.5 | nbody_system.time) self.assertEquals(len(collisions.particles(0)), 3) self.assertEquals(len(collisions.particles(1)), 3) self.assertEquals(len(particles - collisions.particles(0) - collisions.particles(1)), 1) self.assertEquals( abs(collisions.particles(0).x - collisions.particles(1).x) < (collisions.particles(0).radius + collisions.particles(1).radius), [True, True, True], ) sticky_merged = Particles(len(collisions.particles(0))) sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass sticky_merged.radius = collisions.particles(0).radius for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged): merged.position = (p1 + p2).center_of_mass() merged.velocity = (p1 + p2).center_of_mass_velocity() print instance.model_time print instance.particles instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1)) instance.particles.add_particles(sticky_merged) instance.evolve_model(1.0 | nbody_system.time) print print instance.model_time print instance.particles self.assertTrue(collisions.is_set()) self.assertTrue(instance.model_time < 1.0 | nbody_system.time) self.assertEquals(len(collisions.particles(0)), 1) self.assertEquals(len(collisions.particles(1)), 1) self.assertEquals(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2) self.assertEquals( abs(collisions.particles(0).x - collisions.particles(1).x) < (collisions.particles(0).radius + collisions.particles(1).radius), [True], ) instance.stop()
def test11(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura properties" numpy.random.seed(12345) particles = new_plummer_model(10, 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 = Sakura() instance.particles.add_particles(particles) instance.set_dt(1e-3 | nbody_system.time) 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 test06(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura evolve_model, earth-sun system, no SMBH" converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) instance = Sakura(converter) instance.initialize_code() # instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() instance.particles.add_particles(self.new_sun_earth_system()) instance.commit_particles() earth = instance.particles[1] position_at_start = earth.position.x instance.evolve_model(0.25 | units.yr) self.assertAlmostRelativeEqual(position_at_start, earth.position.y, 3) instance.evolve_model(0.5 | units.yr) self.assertAlmostRelativeEqual(position_at_start, -earth.position.x, 3) instance.evolve_model(1.0 | units.yr) self.assertAlmostRelativeEqual(position_at_start, earth.position.x, 3) instance.cleanup_code() instance.stop()
def test06(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura evolve_model, earth-sun system, no SMBH" converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) instance = Sakura(converter, ) instance.initialize_code() # instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() instance.particles.add_particles(self.new_sun_earth_system()) instance.commit_particles() earth = instance.particles[1] position_at_start = earth.position.x instance.evolve_model(0.25 | units.yr) self.assertAlmostRelativeEqual(position_at_start, earth.position.y, 3) instance.evolve_model(0.5 | units.yr) self.assertAlmostRelativeEqual(position_at_start, -earth.position.x, 3) instance.evolve_model(1.0 | units.yr) self.assertAlmostRelativeEqual(position_at_start, earth.position.x, 3) 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.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.1362368884e+37 | units.J, 4) self.assertAlmostRelativeEqual(potential_energy, -4.34842269914e+37 | units.J, 4) self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 4) instance.cleanup_code() instance.stop()
def test11(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura properties" numpy.random.seed(12345) particles = new_plummer_model(100, 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 = Sakura() 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 xtest07(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing effect of Sakura parameter epsilon_squared" converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) particles = self.new_sun_earth_system() particles.rotate(0.0, 0.0, -math.pi / 4) particles.move_to_center() tan_initial_direction = particles[1].vy / particles[1].vx self.assertAlmostEquals(tan_initial_direction, math.tan(math.pi / 4)) tan_final_direction = [] for log_eps2 in range(-9, 10, 2): instance = Sakura(converter, ) instance.initialize_code() instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU**2 # instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() instance.particles.add_particles(particles) instance.commit_particles() instance.evolve_model(0.25 | units.yr) tan_final_direction.append(instance.particles[1].velocity[1] / instance.particles[1].velocity[0]) instance.cleanup_code() instance.stop() # Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees self.assertAlmostEquals(tan_final_direction[0], math.tan(3 * math.pi / 4.0), 2) # Large values of epsilon_squared should result in ~ no interaction self.assertAlmostEquals(tan_final_direction[-1], tan_initial_direction, 2) # Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2 delta = [ abs(tan_final_direction[i + 1] - tan_final_direction[i]) for i in range(len(tan_final_direction) - 1) ] self.assertEquals(delta[len(tan_final_direction) / 2 - 1], max(delta))
def xtest04(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura evolve_model, 2 particles orbiting the SMBH" particles = Particles(2) particles.mass = 1.0 | units.MSun particles.radius = 1.0 | units.RSun particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0] ] | units.km / units.s particles[1].vy = ((constants.G * (10001.0 | units.MSun) / (1.0 | units.AU)).sqrt() + (constants.G * (10000.0 | units.MSun) / (1.0 | units.AU)).sqrt()) particles.move_to_center() print particles instance = Sakura(self.default_converter, ) instance.initialize_code() # instance.parameters.include_smbh = True instance.commit_parameters() instance.particles.add_particles(particles) instance.commit_particles() primary = instance.particles[0] P = 2 * math.pi * primary.x / primary.vy P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001))) position_at_start = primary.position.x instance.evolve_model(P_corrected / 4.0) self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3) instance.evolve_model(P_corrected / 2.0) self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3) instance.evolve_model(P_corrected) self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3) instance.cleanup_code() instance.stop()
def test05(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura evolve_model, 2 particles, no SMBH" particles = Particles(2) particles.mass = 1.0 | units.MSun particles.radius = 1.0 | units.RSun particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0] ] | units.km / units.s particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt() particles.move_to_center() print particles converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) instance = Sakura(converter, ) instance.initialize_code() # instance.parameters.integrator_method = "asakura" instance.commit_parameters() instance.particles.add_particles(particles) instance.commit_particles() primary = instance.particles[0] P = 2 * math.pi * primary.x / primary.vy position_at_start = primary.position.x instance.evolve_model(P / 4.0) self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3) instance.evolve_model(P / 2.0) self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3) instance.evolve_model(P) self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3) instance.cleanup_code() instance.stop()
def xtest04(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura evolve_model, 2 particles orbiting the SMBH" particles = Particles(2) particles.mass = 1.0 | units.MSun particles.radius = 1.0 | units.RSun particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s particles[1].vy = (constants.G * (10001.0 | units.MSun) / (1.0 | units.AU)).sqrt() + ( constants.G * (10000.0 | units.MSun) / (1.0 | units.AU) ).sqrt() particles.move_to_center() print particles instance = Sakura(self.default_converter) instance.initialize_code() # instance.parameters.include_smbh = True instance.commit_parameters() instance.particles.add_particles(particles) instance.commit_particles() primary = instance.particles[0] P = 2 * math.pi * primary.x / primary.vy P_corrected = (P) * (2.0 / (1.0 + math.sqrt(1.0001))) position_at_start = primary.position.x instance.evolve_model(P_corrected / 4.0) self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3) instance.evolve_model(P_corrected / 2.0) self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3) instance.evolve_model(P_corrected) self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3) instance.cleanup_code() instance.stop()
def test05(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura evolve_model, 2 particles, no SMBH" particles = Particles(2) particles.mass = 1.0 | units.MSun particles.radius = 1.0 | units.RSun particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.km / units.s particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt() particles.move_to_center() print particles converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) instance = Sakura(converter) instance.initialize_code() # instance.parameters.integrator_method = "asakura" instance.commit_parameters() instance.particles.add_particles(particles) instance.commit_particles() primary = instance.particles[0] P = 2 * math.pi * primary.x / primary.vy position_at_start = primary.position.x instance.evolve_model(P / 4.0) self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3) instance.evolve_model(P / 2.0) self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3) instance.evolve_model(P) self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3) instance.cleanup_code() instance.stop()
def xtest10(self): if MODULES_MISSING: self.skip("Failed to import a module required for Sakura") print "Testing Sakura collision_detection" particles = Particles(7) particles.mass = 0.00000001 | nbody_system.mass particles.radius = 0.01 | nbody_system.length particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0 ] | nbody_system.length particles.y = 0 | nbody_system.length particles.z = 0 | nbody_system.length particles.velocity = [[2, 0, 0], [-2, 0, 0] ] * 3 + [[-4, 0, 0]] | nbody_system.speed instance = Sakura() instance.initialize_code() instance.parameters.set_defaults() instance.particles.add_particles(particles) collisions = instance.stopping_conditions.collision_detection collisions.enable() instance.evolve_model(1.0 | nbody_system.time) self.assertTrue(collisions.is_set()) self.assertTrue(instance.model_time < 0.5 | nbody_system.time) self.assertEquals(len(collisions.particles(0)), 3) self.assertEquals(len(collisions.particles(1)), 3) self.assertEquals( len(particles - collisions.particles(0) - collisions.particles(1)), 1) self.assertEquals( abs(collisions.particles(0).x - collisions.particles(1).x) < (collisions.particles(0).radius + collisions.particles(1).radius), [True, True, True]) sticky_merged = Particles(len(collisions.particles(0))) sticky_merged.mass = collisions.particles( 0).mass + collisions.particles(1).mass sticky_merged.radius = collisions.particles(0).radius for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged): merged.position = (p1 + p2).center_of_mass() merged.velocity = (p1 + p2).center_of_mass_velocity() print instance.model_time print instance.particles instance.particles.remove_particles( collisions.particles(0) + collisions.particles(1)) instance.particles.add_particles(sticky_merged) instance.evolve_model(1.0 | nbody_system.time) print print instance.model_time print instance.particles self.assertTrue(collisions.is_set()) self.assertTrue(instance.model_time < 1.0 | nbody_system.time) self.assertEquals(len(collisions.particles(0)), 1) self.assertEquals(len(collisions.particles(1)), 1) self.assertEquals( len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2) self.assertEquals( abs(collisions.particles(0).x - collisions.particles(1).x) < (collisions.particles(0).radius + collisions.particles(1).radius), [True]) instance.stop()