def test3(self): code = Hermite() particles_in_binary = self.new_binary(0.1 | nbody_system.mass, 0.1 | nbody_system.mass, 0.01 | nbody_system.length, keyoffset=1) particles_in_binary.radius = 0.001 | nbody_system.length binary = datamodel.Particle(key=3) binary.child1 = particles_in_binary[0] binary.child2 = particles_in_binary[1] binary.radius = 0.5 | nbody_system.length binary.mass = 0.2 | nbody_system.mass encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), interaction_over_code=None) multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.singles_in_binaries.add_particles(particles_in_binary) multiples_code.binaries.add_particle(binary) self.assertEquals(len(multiples_code.singles_in_binaries), 2) self.assertEquals(id(multiples_code.binaries[0].child1.particles_set), id(multiples_code.singles_in_binaries)) multiples_code.commit_particles() self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.components_of_multiples), 2)
def test2(self): code = Hermite() stars = datamodel.Particles(keys=(1, 2, 3, 4)) stars.mass = 1 | nbody_system.mass stars.position = [ [0, 0, 0], [0.5, 0, 0], [2, 0, 0], [-10, 0, 0], ] | nbody_system.length stars.velocity = [ [0, 0, 0], [0, 0.1, 0], [0, -0.1, 0], [0, 0.2, 0], ] | nbody_system.speed stars.radius = 0.5 | nbody_system.length encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), interaction_over_code=None) multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.particles.add_particles(stars) multiples_code.commit_particles() multiples_code.evolve_model(3 | nbody_system.time) self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.multiples[0].components), 2) self.assertEquals(len(multiples_code.particles), 3) self.assertEquals(len(multiples_code.binaries), 1) self.assertEquals(len(multiples_code.singles), 2)
def test5(self): converter = nbody_system.nbody_to_si(units.MSun, units.parsec) code = Hermite(converter) stars = datamodel.Particles(keys=(1, 2)) stars.mass = converter.to_si(1 | nbody_system.mass) stars.position = converter.to_si([[0, 0, 0], [1.2, 0, 0]] | nbody_system.length) stars.velocity = converter.to_si([[0, 0, 0], [0, 0.1, 0]] | nbody_system.speed) stars.radius = converter.to_si(0.5 | nbody_system.length) encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler_si(), resolve_collision_code=self.new_smalln_si(), interaction_over_code=None, G=constants.G) encounter_code.parameters.hard_binary_factor = 1 multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code, G=constants.G) end_time = converter.to_si(1.0 | nbody_system.time) multiples_code.particles.add_particles(stars) multiples_code.commit_particles() multiples_code.evolve_model(end_time) self.assertEquals(len(multiples_code.particles), 1) # 1 multiples with 2 singles self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.multiples[0].components), 2) self.assertEquals(len(multiples_code.binaries), 1) self.assertEquals(len(multiples_code.singles), 0)
def test11(self): code = Hermite() particles_in_binary = self.new_binary(1 | nbody_system.mass, 1 | nbody_system.mass, 0.001 | nbody_system.length, keyoffset=1) particles_in_binary.radius = 0.01 | nbody_system.length encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), ) others = datamodel.Particles(keys=[4, 5, 6]) for i in range(3): others[i].position = [i, 0, 0] | nbody_system.length others[i].velocity = [0, 0, 0] | nbody_system.speed others[i].mass = 0.2 | nbody_system.mass others[i].radius = 0.05 | nbody_system.length multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.singles.add_particles(particles_in_binary) multiples_code.singles.add_particles(others) stopping_condition = multiples_code.stopping_conditions.binaries_change_detection stopping_condition.enable() multiples_code.commit_particles() multiples_code.evolve_model(1 | nbody_system.time) self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.binaries), 1) self.assertEquals(len(multiples_code.components_of_multiples), 2) self.assertEquals(len(multiples_code.singles), 3) self.assertEquals(len(multiples_code.particles), 4) self.assertEquals(len(code.particles), 4) self.assertTrue(stopping_condition.is_set()) multiples_code.particles[-1].velocity = [0, 0, 0] | nbody_system.speed multiples_code.update_model() print multiples_code.particles.key self.assertEquals(len(stopping_condition.particles(0)), 1) self.assertEquals(len(stopping_condition.particles(1)), 0) self.assertEquals(len(stopping_condition.particles(2)), 0) self.assertAlmostRelativeEquals(multiples_code.multiples[0].mass, 2.0 | nbody_system.mass) self.assertAlmostRelativeEquals(multiples_code.particles.mass.sum(), 2.6 | nbody_system.mass) print multiples_code.particles.velocity multiples_code.evolve_model(2 | nbody_system.time) self.assertTrue(stopping_condition.is_set()) self.assertEquals(len(stopping_condition.particles(0)), 0) self.assertEquals(len(stopping_condition.particles(1)), 0) self.assertEquals(len(stopping_condition.particles(2)), 1) self.assertAlmostRelativeEquals(multiples_code.multiples[0].mass, 2.0 | nbody_system.mass) self.assertAlmostRelativeEquals(multiples_code.particles.mass.sum(), 2.6 | nbody_system.mass)
def test4(self): code = Hermite() stars = datamodel.Particles(keys=(1, 2, 3, 4)) stars.mass = 1 | nbody_system.mass stars.position = [ [0, 0, 0], [0.5, 0, 0], [2, 0, 0], [-10, 0, 0], ] | nbody_system.length stars.velocity = [ [0, 0, 0], [0, 0.1, 0], [0, -0.1, 0], [0, 0.2, 0], ] | nbody_system.speed stars.radius = 0.5 | nbody_system.length encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), interaction_over_code=None) multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.particles.add_particles(stars) multiples_code.commit_particles() stopping_condition = multiples_code.stopping_conditions.multiples_change_detection stopping_condition.enable() multiples_code.evolve_model(3 | nbody_system.time) self.assertTrue(stopping_condition.is_set()) self.assertAlmostRelativeEquals(multiples_code.model_time, 0.0075 | nbody_system.time, 4) self.assertEquals(len(stopping_condition.particles(0)), 1) self.assertEquals(len(stopping_condition.particles(1)), 0) self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.multiples[0].components), 2) self.assertEquals(len(multiples_code.particles), 3) # 1 multiples with 2 singles, plus 2 singles free self.assertEquals(len(multiples_code.binaries), 1) self.assertEquals(len(multiples_code.singles), 2) multiples_code.evolve_model(3 | nbody_system.time) self.assertTrue(stopping_condition.is_set()) self.assertAlmostRelativeEquals(multiples_code.model_time, 1.19126 | nbody_system.time, 4) self.assertEquals(len(stopping_condition.particles(0)), 1) # 1 new multiple self.assertEquals(len(stopping_condition.particles(1)), 1) # 1 dissolved multiple self.assertEquals(len(multiples_code.multiples[0].components), 2) self.assertEquals(len(multiples_code.particles), 3) # 1 multiples with 2 singles, plus 2 singles free self.assertEquals(len(multiples_code.binaries), 1) self.assertEquals(len(multiples_code.singles), 2)
def test6(self): converter = nbody_system.nbody_to_si(units.MSun, units.parsec) code = Hermite(converter) stars = datamodel.Particles(keys=(1, 2, 3, 4)) stars.mass = converter.to_si(1 | nbody_system.mass) stars.position = converter.to_si( [[0, 0, 0], [1.2, 0, 0], [100, 0, 0], [100, 1.2, 0]] | nbody_system.length) stars.velocity = converter.to_si([ [0, 0, 0], [0, 0.1, 0], [0, 0, 0], [0, 0, 0.1], ] | nbody_system.speed) stars.radius = converter.to_si(0.5 | nbody_system.length) encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler_si(), resolve_collision_code=self.new_smalln_si(), interaction_over_code=None, G=constants.G) encounter_code.small_scale_factor = 1.0 multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code, G=constants.G) multiples_code.must_handle_one_encounter_per_stopping_condition = False multiples_code.particles.add_particles(stars) multiples_code.commit_particles() stopping_condition = multiples_code.stopping_conditions.multiples_change_detection stopping_condition.enable() end_time = converter.to_si(3.0 | nbody_system.time) print end_time.as_quantity_in(units.Myr) multiples_code.evolve_model(end_time) self.assertTrue(stopping_condition.is_set()) print multiples_code.model_time.as_quantity_in(units.Myr) self.assertAlmostRelativeEquals(multiples_code.model_time, 7.99844 | units.Myr, 4) self.assertEquals(len(stopping_condition.particles(0)), 2) self.assertEquals(len(stopping_condition.particles(1)), 0) self.assertEquals(len(multiples_code.particles), 2) # 1 multiples with 2 singles self.assertEquals(len(multiples_code.multiples), 2) self.assertEquals(len(multiples_code.binaries), 2) self.assertEquals(len(multiples_code.multiples[0].components), 2) self.assertEquals(len(multiples_code.multiples[1].components), 2) self.assertEquals(len(multiples_code.singles), 0) self.assertEquals(len(multiples_code.all_singles), 4)
def test14(self): code = Hermite() encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), ) center_of_mass_particles = datamodel.Particles(5) center_of_mass_particles.position = (numpy.asarray(range(5))).reshape( 5, 1) * ([1.0, 0.0, 0.0] | nbody_system.length) center_of_mass_particles.velocity = [0.0, 0.0, 0.0 ] | nbody_system.speed center_of_mass_particles.radius = 0.05 | nbody_system.length binaries, singles_in_binaries = self.create_binaries( center_of_mass_particles, 1 | nbody_system.mass, 0.1 | nbody_system.mass, 0.00000001 | nbody_system.length) multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.singles_in_binaries.add_particles(singles_in_binaries) multiples_code.binaries.add_particles(binaries) multiples_code.commit_particles() #stopping_condition = multiples_code.stopping_conditions.encounter_detection #stopping_condition.enable() stopping_condition = multiples_code.stopping_conditions.binaries_change_detection stopping_condition.enable() for x in multiples_code.binaries: print x.key, x.child1.key, x.child2.key multiples_code.evolve_model(2 | nbody_system.time) self.assertTrue(stopping_condition.is_set()) for x in multiples_code.binaries: print x.key, x.child1.key, x.child2.key for x in stopping_condition.particles(0): print "NEW:", x.key, x.child1.key, x.child2.key for x in stopping_condition.particles(1): print "REMOVED:", x.key, x.child1.key, x.child2.key for x in stopping_condition.particles(2): print "UPDATED:", x.key, x.child1.key, x.child2.key for x in multiples_code.singles: print x.key, x.mass self.assertEquals( len(multiples_code.singles_in_binaries) + len(multiples_code.singles), 2 * len(center_of_mass_particles)) self.assertEquals( len(multiples_code.binaries) - len(stopping_condition.particles(0)) + len(stopping_condition.particles(1)), len(center_of_mass_particles))
def test15(self): code = Hermite() encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), ) n = 10 center_of_mass_particles = plummer.new_plummer_model( n, random=numpy.random.mtrand.RandomState(1)) center_of_mass_particles.radius = 0.5 | nbody_system.length center_of_mass_particles.velocity *= 0 binaries, singles_in_binaries = self.create_binaries( center_of_mass_particles, 0.999 * ((1.0 | nbody_system.mass) / n), 0.001 * ((1.0 | nbody_system.mass) / n), 0.00001 | nbody_system.length) multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.singles_in_binaries.add_particles(singles_in_binaries) multiples_code.binaries.add_particles(binaries) multiples_code.commit_particles() #stopping_condition = multiples_code.stopping_conditions.encounter_detection #stopping_condition.enable() stopping_condition = multiples_code.stopping_conditions.binaries_change_detection stopping_condition.enable() for x in multiples_code.binaries: print x.key, x.child1.key, x.child2.key multiples_code.evolve_model(2 | nbody_system.time) self.assertTrue(stopping_condition.is_set()) for x in multiples_code.binaries: print x.key, x.child1.key, x.child2.key for x in stopping_condition.particles(0): print "NEW:", x.key, x.child1.key, x.child2.key for x in stopping_condition.particles(1): print "REMOVED:", x.key, x.child1.key, x.child2.key for x in stopping_condition.particles(2): print "UPDATED:", x.key, x.child1.key, x.child2.key for x in multiples_code.singles: print x.key, x.mass self.assertEquals( len(multiples_code.binaries) - len(stopping_condition.particles(0)) + len(stopping_condition.particles(1)), len(center_of_mass_particles))
def test0(self): code = Hermite() stars = datamodel.Particles(2) stars.mass = 1 | nbody_system.mass stars.position = [[0, 0, 0], [1.2, 0, 0]] | nbody_system.length stars.velocity = [[0, 0, 0], [0, 0.1, 0]] | nbody_system.speed stars.radius = 0.5 | nbody_system.length encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), interaction_over_code=None) encounter_code.parameters.hard_binary_factor = 1 encounter_code.small_scale_factor = 1 multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.particles.add_particles(stars) multiples_code.commit_particles() multiples_code.evolve_model(0.6 | nbody_system.time) self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.binaries), 1)
def test12(self): code = Hermite() particles_in_binary = self.new_binary(1 | nbody_system.mass, 1 | nbody_system.mass, 0.001 | nbody_system.length, keyoffset=10) particles_in_binary.radius = 0.01 | nbody_system.length encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), ) binary = datamodel.Particle(key=20) binary.child1 = particles_in_binary[0] binary.child2 = particles_in_binary[1] binary.position = [1, 0, 1] | nbody_system.length particles_in_binary.position += [1, 0, 1] | nbody_system.length others = datamodel.Particles(keys=[4, 5, 6]) for i in range(3): others[i].position = [i * 10, 0, 0] | nbody_system.length others[i].velocity = [0, 0, 0] | nbody_system.speed others[i].mass = 0.2 | nbody_system.mass others[i].radius = 0.05 | nbody_system.length multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.particles.add_particles(others) multiples_code.singles_in_binaries.add_particles(particles_in_binary) multiples_code.binaries.add_particle(binary) multiples_code.commit_particles() print multiples_code.particles self.assertEquals(len(multiples_code.particles), 4) self.assertAlmostRelativeEquals(multiples_code.particles[-1].position, [1, 0, 1] | nbody_system.length)
def run(): # Generate initial conditions stars = get_triangle() # Setup dynamics grav = new_ph4() encounter_code = encounters.HandleEncounter( kepler_code=new_kepler(), resolve_collision_code=new_smalln(), interaction_over_code=None, ) multiples_code = encounters.Multiples( gravity_code=grav, handle_encounter_code=encounter_code, ) multiples_code.particles.add_particles(stars) multiples_code.commit_particles() # Setup simulation parameters and diagnostics t = 0. | nbody_system.time t_end = 100. | nbody_system.time dt = 1.0 | nbody_system.time stars = multiples_code.all_singles N = len(stars) m = stars.mass pos = stars.position vel = stars.velocity print 't=', t.number, 'N=', len(multiples_code.particles), 'Ns=', len( multiples_code.singles), 'Nb=', len( multiples_code.binaries), 'Nsib=', len( multiples_code.singles_in_binaries), 'Nm=', len( multiples_code.multiples), 'Ncom=', len( multiples_code.components_of_multiples ), 'Nbin_manual=', check_number_of_binaries( N, m, pos, vel) # Start the integration while t < t_end: t += dt multiples_code.evolve_model(t) stars = multiples_code.all_singles N = len(stars) m = stars.mass pos = stars.position vel = stars.velocity print 't=', t.number, 'N=', len(multiples_code.particles), 'Ns=', len( multiples_code.singles), 'Nb=', len( multiples_code.binaries), 'Nsib=', len( multiples_code.singles_in_binaries), 'Nm=', len( multiples_code.multiples), 'Ncom=', len( multiples_code.components_of_multiples ), 'Nbin_manual=', check_number_of_binaries( N, m, pos, vel) # Cleanup grav.cleanup_code() grav.stop()
def kira(tend, N, R, Nbin): logging.basicConfig(level=logging.ERROR) #encounters.LOG_ENERGY.setLevel(logging.DEBUG) mass = new_salpeter_mass_distribution(N, mass_min=10 | units.MSun) converter = nbody_system.nbody_to_si(mass.sum(), R) code = Hermite(converter) stars = new_plummer_model(N, convert_nbody=converter) stars.mass = mass stars.radius = 0.01 / len(stars) | R.unit single_stars, binary_stars, singles_in_binaries = make_secondaries( stars, Nbin) print binary_stars stellar = SeBa() stellar.particles.add_particles(single_stars) stellar.particles.add_particles(singles_in_binaries) stellar.binaries.add_particles(binary_stars) channel_to_stars = stellar.particles.new_channel_to(stars) encounter_code = encounters.HandleEncounter( kepler_code=new_kepler(converter), resolve_collision_code=new_smalln(converter), interaction_over_code=None, G=constants.G) multiples_code = encounters.Multiples(gravity_code=code, handle_encounter_code=encounter_code, G=constants.G) multiples_code.particles.add_particles((stars - binary_stars).copy()) multiples_code.singles_in_binaries.add_particles(singles_in_binaries) multiples_code.binaries.add_particles(binary_stars) multiples_code.commit_particles() channel_from_stars_to_particles = stellar.particles.new_channel_to( multiples_code.particles) stopping_condition = multiples_code.stopping_conditions.binaries_change_detection stopping_condition.enable() t = quantities.linspace(0 * tend, tend, 11) for ti in t: print "t, Energy=", ti, multiples_code.particles.mass.sum( ), multiples_code.get_total_energy() multiples_code.evolve_model(ti) print "at t=", multiples_code.model_time, "N-multiples:", len( multiples_code.multiples) if stopping_condition.is_set(): resolve_changed_binaries(stopping_condition, stellar, converter) stellar.evolve_model(ti) channel_from_stars_to_particles.copy_attributes(["mass", "radius"]) update_dynamical_binaries_from_stellar(stellar, multiples_code, converter) print "Lagrangian radii:", multiples_code.all_singles.LagrangianRadii( converter) print "MC.particles", multiples_code.particles print "Lagrangian radii:", multiples_code.particles.LagrangianRadii( converter) print "t, Energy=", ti, multiples_code.get_total_energy() multiples_code.stop() stellar.stop()
def test10(self): code = Hermite() particles_in_binary = self.new_binary(0.1 | nbody_system.mass, 0.1 | nbody_system.mass, 0.01 | nbody_system.length, keyoffset=1) particles_in_binary.radius = 0.01 | nbody_system.length encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), ) encounter_code.parameters.hard_binary_factor = 1 encounter_code.small_scale_factor = 1 others = datamodel.Particles(key=[4, 5, 6]) for i in range(3): others[i].position = [i, 0, 0] | nbody_system.length others[i].velocity = [0, 0, i] | nbody_system.speed others[i].mass = 1 | nbody_system.mass others[i].radius = 0.05 | nbody_system.length multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.must_handle_one_encounter_per_stopping_condition = False multiples_code.singles.add_particles(particles_in_binary) multiples_code.singles.add_particles(others) multiples_code.commit_particles() multiples_code.evolve_model(1 | nbody_system.time) self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.components_of_multiples), 2) self.assertEquals(len(multiples_code.singles), 3) self.assertEquals(len(multiples_code.particles), 4) self.assertEquals(len(code.particles), 4) self.assertEquals(id(multiples_code.singles_in_binaries), id(multiples_code.binaries[0].child1.particles_set)) self.assertEquals( id(multiples_code.components_of_multiples), id(multiples_code.multiples[0].components[0].particles_set)) #multiples_code.singles_in_binaries[0].mass = 0.2 | nbody_system.mass self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 1.1 | nbody_system.mass) self.assertAlmostRelativeEquals(multiples_code.particles.mass.sum(), 0.1 + 0.1 + 3.0 | nbody_system.mass) multiples_code.update_model() self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 1.1 | nbody_system.mass) index = -1 if not code.particles[index].mass > 1.0 | nbody_system.mass: index = -2 self.assertAlmostRelativeEquals(code.particles[index].mass, 1.1 | nbody_system.mass) multiples_code.singles_in_binaries[0].mass += 0.2 | nbody_system.mass multiples_code.update_model() self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 1.3 | nbody_system.mass) self.assertAlmostRelativeEquals(code.particles[index].mass, 1.3 | nbody_system.mass)
def test9(self): code = Hermite() particles_in_binary = self.new_binary(0.1 | nbody_system.mass, 0.1 | nbody_system.mass, 0.01 | nbody_system.length, keyoffset=1) particles_in_binary.radius = 0.001 | nbody_system.length binary = datamodel.Particle(key=3) binary.child1 = particles_in_binary[0] binary.child2 = particles_in_binary[1] binary.radius = 0.5 | nbody_system.length binary.mass = 0.2 | nbody_system.mass encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), ) others = datamodel.Particles(key=[4, 5, 6]) for i in range(3): others[i].position = [i, 0, 0] | nbody_system.length others[i].velocity = [0, 0, i] | nbody_system.speed others[i].mass = 1 | nbody_system.mass others[i].radius = 0 | nbody_system.length multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.singles_in_binaries.add_particles(particles_in_binary) multiples_code.binaries.add_particle(binary) multiples_code.singles.add_particles(others) multiples_code.commit_particles() self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.components_of_multiples), 2) self.assertEquals(len(multiples_code.singles), 3) self.assertEquals(len(multiples_code.particles), 4) self.assertEquals(len(code.particles), 4) self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 0.2 | nbody_system.mass) self.assertAlmostRelativeEquals(code.particles[-1].mass, 0.2 | nbody_system.mass) self.assertAlmostRelativeEquals(code.particles[-1].position, [0, 0, 0] | nbody_system.length, 6) self.assertAlmostRelativeEquals(code.particles[-1].velocity, [0, 0, 0] | nbody_system.speed, 6) multiples_code.update_model() self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 0.2 | nbody_system.mass) self.assertAlmostRelativeEquals(code.particles[-1].mass, 0.2 | nbody_system.mass) self.assertAlmostRelativeEquals(code.particles[-1].position, [0, 0, 0] | nbody_system.length, 6) self.assertAlmostRelativeEquals(code.particles[-1].velocity, [0, 0, 0] | nbody_system.speed, 6) multiples_code.singles_in_binaries[0].mass = 0.2 | nbody_system.mass multiples_code.update_model() print code.particles.mass self.assertAlmostRelativeEquals(multiples_code.particles[-1].mass, 0.3 | nbody_system.mass) self.assertAlmostRelativeEquals(code.particles[-1].mass, 0.3 | nbody_system.mass) print code.particles[-1].position print code.particles[-1].velocity self.assertAlmostRelativeEquals(code.particles[-1].position, [0.00166666666667, 0, 0] | nbody_system.length, 6) self.assertAlmostRelativeEquals(code.particles[-1].velocity, [0, 0.7453559925, 0] | nbody_system.speed, 6)
def test8(self): code = Hermite() particles_in_binary = self.new_binary(0.1 | nbody_system.mass, 0.1 | nbody_system.mass, 0.01 | nbody_system.length, keyoffset=1) particles_in_binary.radius = 0.001 | nbody_system.length binary = datamodel.Particle(key=3) binary.child1 = particles_in_binary[0] binary.child2 = particles_in_binary[1] binary.radius = 0.5 | nbody_system.length binary.mass = 0.2 | nbody_system.mass binary.position = [0.0, 0.0, 0.0] | nbody_system.length binary.velocity = [0.0, 0.0, 0.0] | nbody_system.speed encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler(), resolve_collision_code=self.new_smalln(), interaction_over_code=None) encounter_code.parameters.hard_binary_factor = 1 encounter_code.small_scale_factor = 1 multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code) multiples_code.singles_in_binaries.add_particles(particles_in_binary) multiples_code.binaries.add_particle(binary) multiples_code.must_handle_one_encounter_per_stopping_condition = False field_particle = datamodel.Particle(key=4) field_particle.mass = 0.5 | nbody_system.mass field_particle.radius = 0.1 | nbody_system.length field_particle.position = [0.0, 0.2, 0.0] | nbody_system.length field_particle.velocity = [0.0, 0.0, 0.0] | nbody_system.speed multiples_code.singles.add_particle(field_particle) self.assertEquals(len(multiples_code.singles_in_binaries), 2) self.assertEquals(id(multiples_code.binaries[0].child1.particles_set), id(multiples_code.singles_in_binaries)) multiples_code.commit_particles() multiples_code.multiples.radius = 0.5 | nbody_system.length initial_energy = multiples_code.get_total_energy() self.assertEquals(len(multiples_code.multiples), 1) self.assertEquals(len(multiples_code.components_of_multiples), 2) self.assertEquals(len(multiples_code.particles), 2) stopping_condition = multiples_code.stopping_conditions.encounter_detection stopping_condition.enable() singles = datamodel.Particles() singles.add_particles(particles_in_binary) singles.add_particle(field_particle) singles_energy = singles.kinetic_energy() + singles.potential_energy( G=nbody_system.G) self.assertAlmostRelativeEquals(initial_energy, singles_energy, 3) multiples_code.evolve_model(2 | nbody_system.time) final_energy = multiples_code.get_total_energy() self.assertTrue(stopping_condition.is_set()) self.assertAlmostRelativeEquals(initial_energy, final_energy, 7)
def test7(self): converter = nbody_system.nbody_to_si(units.MSun, units.parsec) code = Hermite(converter) stars = datamodel.Particles(keys=(1, 2)) stars.mass = converter.to_si(1 | nbody_system.mass) stars.position = converter.to_si([ [0, 0, 0], [1.1, 0, 0], ] | nbody_system.length) stars.velocity = converter.to_si([ [0, 0, 0], [-0.5, 1.5, 0], ] | nbody_system.speed) stars.radius = converter.to_si(0.55 | nbody_system.length) encounter_code = encounters.HandleEncounter( kepler_code=self.new_kepler_si(), resolve_collision_code=self.new_smalln_si(), interaction_over_code=None, G=constants.G) encounter_code.small_scale_factor = 1.0 encounter_code.parameters.hard_binary_factor = 1 multiples_code = encounters.Multiples( gravity_code=code, handle_encounter_code=encounter_code, G=constants.G) multiples_code.must_handle_one_encounter_per_stopping_condition = False multiples_code.singles.add_particles(stars) multiples_code.commit_particles() stopping_condition = multiples_code.stopping_conditions.encounter_detection stopping_condition.enable() end_time = converter.to_si(3.0 | nbody_system.time) print end_time.as_quantity_in(units.Myr) multiples_code.evolve_model(end_time) self.assertTrue(stopping_condition.is_set()) print multiples_code.model_time.as_quantity_in(units.Myr) #self.assertAlmostRelativeEquals(multiples_code.model_time , 5.96955 | units.Myr, 4) self.assertEquals(len(stopping_condition.particles(0)), 1) model = stopping_condition.particles(0)[0] self.assertEquals(len(model.particles_before_encounter), 2) self.assertEquals(len(model.particles_after_encounter), 2) before = model.particles_before_encounter after = model.particles_after_encounter self.assertAlmostRelativeEquals(before.center_of_mass(), after.center_of_mass(), 7) self.assertAlmostRelativeEquals(before.center_of_mass_velocity(), after.center_of_mass_velocity(), 7) total_energy_before = before.kinetic_energy( ) + before.potential_energy(G=constants.G) total_energy_after = after.kinetic_energy() + after.potential_energy( G=constants.G) self.assertAlmostRelativeEquals(total_energy_before, total_energy_after, 7)
def kira(tend, N, R, Nbin): logging.basicConfig(level=logging.ERROR) mass = new_salpeter_mass_distribution(N, mass_min=10 | units.MSun) converter = nbody_system.nbody_to_si(mass.sum(), R) code = Hermite(converter) stars = new_plummer_model(N, convert_nbody=converter) stars.mass = mass stars.radius = 0.01 / len(stars) | R.unit single_stars, binary_stars, singles_in_binaries \ = make_secondaries(stars, Nbin) print binary_stars stellar = SeBa() stellar.particles.add_particles(single_stars) stellar.particles.add_particles(singles_in_binaries) stellar.binaries.add_particles(binary_stars) channel_to_stars = stellar.particles.new_channel_to(stars) encounter_code = encounters.HandleEncounter( kepler_code=new_kepler(converter), resolve_collision_code=new_smalln(converter), interaction_over_code=None, G=constants.G) multiples_code = encounters.Multiples(gravity_code=code, handle_encounter_code=encounter_code, G=constants.G) multiples_code.particles.add_particles((stars - binary_stars).copy()) multiples_code.singles_in_binaries.add_particles(singles_in_binaries) multiples_code.binaries.add_particles(binary_stars) multiples_code.commit_particles() channel_from_stars_to_particles \ = stellar.particles.new_channel_to(multiples_code.particles) stopping_condition \ = multiples_code.stopping_conditions.binaries_change_detection stopping_condition.enable() from matplotlib import pyplot from distinct_colours import get_distinct pyplot.rcParams.update({'font.size': 30}) figure = pyplot.figure(figsize=(12, 9)) ax = pyplot.gca() ax.get_yaxis().get_major_formatter().set_useOffset(False) ax.xaxis._autolabelpos = True ax.yaxis._autolabelpos = True color = get_distinct(2) pyplot.scatter(numpy.log10( stellar.binaries.semi_major_axis.value_in(units.AU)), stellar.binaries.eccentricity, c=color[0], s=200, lw=0) t = quantities.linspace(0 * tend, tend, 11) for ti in t: print "t, Energy=", ti, multiples_code.particles.mass.sum(), \ multiples_code.get_total_energy() multiples_code.evolve_model(ti) print "at t=", multiples_code.model_time, \ "Nmultiples:", len(multiples_code.multiples) if stopping_condition.is_set(): resolve_changed_binaries(stopping_condition, stellar, converter) stellar.evolve_model(ti) channel_from_stars_to_particles.copy_attributes(["mass", "radius"]) update_dynamical_binaries_from_stellar(stellar, multiples_code, converter) print "Lagrangian radii:", \ multiples_code.all_singles.LagrangianRadii(converter) print "MC.particles", multiples_code.particles print "Lagrangian radii:", \ multiples_code.particles.LagrangianRadii(converter) print "t, Energy=", ti, multiples_code.get_total_energy() pyplot.scatter(numpy.log10( stellar.binaries.semi_major_axis.value_in(units.AU)), stellar.binaries.eccentricity, c=color[1], lw=0, s=50) pyplot.xlabel("$\log_{10}(a/R_\odot)$") pyplot.ylabel("eccentricity") save_file = 'kira_a_vs_e.pdf' pyplot.savefig(save_file) print '\nSaved figure in file', save_file, '\n' pyplot.show() stellar.stop()