Ejemplo n.º 1
0
    def test3(self):
        convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
                                                 1.0 | units.yr / (2.0 * pi))
        instance = Mikkola(convert_nbody)
        instance.parameters.lightspeed = constants.c
        stars = self.new_system_of_Hulse_Taylor_pulsar()
        instance.particles.add_particles(stars)
        Hulse = stars[0]
        Taylor = stars[1]

        postion_at_start = Taylor.position.value_in(units.AU)[0]

        #orbital period
        #see http://www.johnstonsarchive.net/relativity/binpulsar.html
        period_HTpulsar = 7.75 | units.hour
        #period_HTpulsar = 77.51939106 | units.hour
        # period for abseidal motion
        #        period_HTpulsar = 85.0 | units.yr #4.2degrees/year
        #period_HTpulsar = 1.0 | units.yr
        instance.evolve_model(period_HTpulsar)
        channel = instance.particles.new_channel_to(stars)
        channel.copy()

        postion_after_full_rotation = Taylor.position.value_in(units.AU)[0]

        print("Time=", instance.model_time, period_HTpulsar)
        self.assertAlmostEqual(postion_at_start, postion_after_full_rotation,
                               3)

        instance.stop()
        del instance
Ejemplo n.º 2
0
 def test16(self):
     particles = datamodel.Particles(3)
     particles.mass = [0.1, 0.1, 0.0001] | nbody_system.mass
     particles.radius = [0.3, 0.3, 0.1] | nbody_system.length
     particles.x = [-0.5, 0.5, 10] | nbody_system.length
     particles.y = 0 | nbody_system.length
     particles.z = 0 | nbody_system.length
     particles.velocity = [0, 0, 0] | nbody_system.speed
     particles[-1].vy = 10 | nbody_system.speed
     instance = Mikkola()
     instance.initialize_code()
     instance.parameters.set_defaults()
     instance.parameters.lightspeed = 0 | nbody_system.speed
     instance.particles.add_particles(particles)
     collisions = instance.stopping_conditions.collision_detection
     collisions.enable()
     instance.evolve_model(10.0 | nbody_system.time)
     print(instance.particles.position)
     self.assertTrue(collisions.is_set())
     print(instance.model_time)
     print(len(collisions.particles(0)))
     self.assertTrue(instance.model_time < 2 | nbody_system.time)
     print(collisions.particles(0).key)
     print(collisions.particles(1).key)
     self.assertEqual(len(collisions.particles(0)), 1)
     self.assertEqual(len(collisions.particles(1)), 1)
     instance.stop()
Ejemplo n.º 3
0
    def test3(self):
        convert_nbody=nbody_system.nbody_to_si(1.0|units.MSun, 1.0|units.yr/(2.0*pi))
        instance = Mikkola(convert_nbody)
        instance.parameters.lightspeed = constants.c
        stars = self.new_system_of_Hulse_Taylor_pulsar()
        instance.particles.add_particles(stars)
        Hulse = stars[0]
        Taylor = stars[1]
        
        postion_at_start = Taylor.position.value_in(units.AU)[0]
        
        #orbital period
        #see http://www.johnstonsarchive.net/relativity/binpulsar.html
        period_HTpulsar = 7.75 | units.hour
        #period_HTpulsar = 77.51939106 | units.hour
        # period for abseidal motion
        #        period_HTpulsar = 85.0 | units.yr #4.2degrees/year
        #period_HTpulsar = 1.0 | units.yr 
        instance.evolve_model(period_HTpulsar)
        channel = instance.particles.new_channel_to(stars)
        channel.copy()

        postion_after_full_rotation = Taylor.position.value_in(units.AU)[0]
       
        print "Time=", instance.model_time, period_HTpulsar
        self.assertAlmostEqual(postion_at_start, postion_after_full_rotation, 3)
        
        instance.stop()
        del instance
Ejemplo n.º 4
0
    def test14(self):

        convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
                                                 1.0 | units.yr / (2.0 * pi))
        stars = datamodel.Stars(3)
        stars[0].mass = 1.0 | units.MSun
        stars[0].radius = 1.0 | units.RSun
        stars[0].position = [0.0, 0, 0] | units.km
        stars[0].velocity = [0.0, 0.0, 0.0] | units.km / units.s

        stars[1].mass = 1.0 | units.MSun
        stars[1].radius = 1.0 | units.RSun
        stars[1].position = [0.1, 0, 0] | units.RSun
        stars[1].velocity = [-0.4, 0.0, 0.0] | units.km / units.s

        stars[2].mass = 1e-9 | units.MSun
        stars[2].radius = 1.0 | units.RSun
        stars[2].position = [10000, 0, 0] | units.RSun
        stars[2].velocity = [0.0, -100, 0.0] | units.km / units.s

        instance = Mikkola(convert_nbody)
        instance.particles.add_particles(stars)
        instance.evolve_model(0.3 | units.yr)

        pos11 = quantities.as_vector_quantity(instance.get_position(1))
        pos12 = quantities.as_vector_quantity(instance.get_position(2))
        instance.stop()

        convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
                                                 1.0 | units.yr / (2.0 * pi))

        instance = Mikkola(convert_nbody)
        stars = datamodel.Stars(2)
        stars[0].mass = 1.0 | units.MSun
        stars[0].radius = 1.0 | units.RSun
        stars[0].position = [0.0, 0, 0] | units.km
        stars[0].velocity = [0.0, 0.0, 0.0] | units.km / units.s

        stars[1].mass = 1.0 | units.MSun
        stars[1].radius = 1.0 | units.RSun
        stars[1].position = [0.1, 0, 0] | units.RSun
        stars[1].velocity = [-0.4, 0.0, 0.0] | units.km / units.s

        instance.particles.add_particles(stars)
        self.assertRaises(exceptions.AmuseException, instance.evolve_model,
                          0.3 | units.yr)
        pos21 = quantities.as_vector_quantity(instance.get_position(1))
        pos22 = quantities.as_vector_quantity(instance.get_position(2))
        instance.stop()

        # positions will not be the same but distances will be comparable
        self.assertAlmostRelativeEquals((pos22 - pos21).length(),
                                        (pos12 - pos11).length(), 1)
Ejemplo n.º 5
0
    def test14(self):
        
        convert_nbody=nbody_system.nbody_to_si(1.0|units.MSun, 1.0|units.yr/(2.0*pi))
        stars = datamodel.Stars(3)
        stars[0].mass = 1.0 | units.MSun
        stars[0].radius = 1.0| units.RSun
        stars[0].position = [0.0, 0, 0] | units.km
        stars[0].velocity = [0.0,0.0,0.0] | units.km/units.s

        stars[1].mass = 1.0 | units.MSun
        stars[1].radius = 1.0| units.RSun
        stars[1].position = [0.1, 0, 0] | units.RSun
        stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
        
        
        stars[2].mass = 1e-9 | units.MSun
        stars[2].radius = 1.0| units.RSun
        stars[2].position = [10000, 0, 0] | units.RSun
        stars[2].velocity = [0.0, -100, 0.0] | units.km/units.s
        
        
        instance = Mikkola(convert_nbody)
        instance.particles.add_particles(stars)
        instance.evolve_model(0.3 | units.yr)
        
        pos11 = quantities.as_vector_quantity(instance.get_position(1))
        pos12 = quantities.as_vector_quantity(instance.get_position(2))
        instance.stop()
        
        convert_nbody=nbody_system.nbody_to_si(1.0|units.MSun, 1.0|units.yr/(2.0*pi))
        
        instance = Mikkola(convert_nbody)
        stars = datamodel.Stars(2)
        stars[0].mass = 1.0 | units.MSun
        stars[0].radius = 1.0| units.RSun
        stars[0].position = [0.0, 0, 0] | units.km
        stars[0].velocity = [0.0,0.0,0.0] | units.km/units.s

        stars[1].mass = 1.0 | units.MSun
        stars[1].radius = 1.0| units.RSun
        stars[1].position = [0.1, 0, 0] | units.RSun
        stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
        
        
        instance.particles.add_particles(stars)
        self.assertRaises(exceptions.AmuseException, instance.evolve_model, 0.3 | units.yr)  
        pos21 = quantities.as_vector_quantity(instance.get_position(1))
        pos22 = quantities.as_vector_quantity(instance.get_position(2))
        instance.stop()
        
        # positions will not be the same but distances will be comparable
        self.assertAlmostRelativeEquals((pos22-pos21).length(), (pos12-pos11).length(), 1)
Ejemplo n.º 6
0
    def test8(self):
        convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
                                                 1.0 | units.yr / (2.0 * pi))

        stars = datamodel.Stars(3)
        stars[0].mass = 1.0 | units.MSun
        stars[0].radius = 1.0 | units.RSun
        stars[0].position = [0.0, 0, 0] | units.km
        stars[0].velocity = [0.0, 0.0, 0.0] | units.km / units.s

        stars[1].mass = 1.0 | units.MSun
        stars[1].radius = 1.0 | units.RSun
        stars[1].position = [0.1, 0, 0] | units.RSun
        stars[1].velocity = [-0.4, 0.0, 0.0] | units.km / units.s

        stars[2].mass = 0.01 | units.MSun
        stars[2].radius = 1.0 | units.RSun
        stars[2].position = [6000, 0, 0] | units.RSun
        stars[2].velocity = [0.0, -10, 0.0] | units.km / units.s

        instance1 = Mikkola(convert_nbody)
        instance1.particles.add_particles(stars)
        instance1.evolve_model(0.45 | units.yr)

        pos11 = quantities.as_vector_quantity(instance1.get_position(1))
        pos12 = quantities.as_vector_quantity(instance1.get_position(2))
        posmerger1 = quantities.as_vector_quantity(instance1.get_position(4))
        instance1.stop()

        instance2 = Mikkola(convert_nbody)
        instance2.particles.add_particles(stars)
        instance2.evolve_model(0.15 | units.yr)
        self.assertAlmostRelativeEquals(instance2.model_time, 0.15 | units.yr,
                                        3)
        instance2.evolve_model(0.3 | units.yr)
        print(instance2.model_time.as_quantity_in(units.yr))
        self.assertAlmostRelativeEquals(instance2.model_time, 0.45 | units.yr,
                                        3)

        pos21 = quantities.as_vector_quantity(instance2.get_position(1))
        pos22 = quantities.as_vector_quantity(instance2.get_position(2))
        posmerger2 = quantities.as_vector_quantity(instance2.get_position(4))
        print(pos11, pos21)
        print(pos12, pos22)
        print(posmerger1, posmerger2)
        instance2.stop()

        self.assertAlmostRelativeEquals(pos11, pos21)
        self.assertAlmostRelativeEquals(pos12, pos22)
        self.assertAlmostRelativeEquals(posmerger1[0], posmerger2[0], 4)
        self.assertAlmostRelativeEquals(posmerger1[1], posmerger2[1], 1)
Ejemplo n.º 7
0
    def test8(self):
        convert_nbody=nbody_system.nbody_to_si(1.0|units.MSun, 1.0|units.yr/(2.0*pi))
        
        
        stars = datamodel.Stars(3)
        stars[0].mass = 1.0 | units.MSun
        stars[0].radius = 1.0| units.RSun
        stars[0].position = [0.0, 0, 0] | units.km
        stars[0].velocity = [0.0,0.0,0.0] | units.km/units.s

        stars[1].mass = 1.0 | units.MSun
        stars[1].radius = 1.0| units.RSun
        stars[1].position = [0.1, 0, 0] | units.RSun
        stars[1].velocity = [-0.4, 0.0, 0.0] | units.km/units.s
        
        
        stars[2].mass = 0.01 | units.MSun
        stars[2].radius = 1.0| units.RSun
        stars[2].position = [6000, 0, 0] | units.RSun
        stars[2].velocity = [0.0, -10, 0.0] | units.km/units.s
        
        
        instance1 = Mikkola(convert_nbody)
        instance1.particles.add_particles(stars)
        instance1.evolve_model(0.45 | units.yr)
        
        pos11 = quantities.as_vector_quantity(instance1.get_position(1))
        pos12 = quantities.as_vector_quantity(instance1.get_position(2))
        posmerger1 = quantities.as_vector_quantity(instance1.get_position(4))
        instance1.stop()
        
        instance2 = Mikkola(convert_nbody)
        instance2.particles.add_particles(stars)
        instance2.evolve_model(0.15 | units.yr)
        self.assertAlmostRelativeEquals(instance2.model_time,0.15 | units.yr, 3)
        instance2.evolve_model(0.3 | units.yr)
        print instance2.model_time.as_quantity_in(units.yr)
        self.assertAlmostRelativeEquals(instance2.model_time, 0.45| units.yr, 3)
        
        pos21 = quantities.as_vector_quantity(instance2.get_position(1))
        pos22 = quantities.as_vector_quantity(instance2.get_position(2))
        posmerger2 = quantities.as_vector_quantity(instance2.get_position(4))
        print pos11, pos21
        print pos12, pos22
        print posmerger1, posmerger2
        instance2.stop()
        
        self.assertAlmostRelativeEquals(pos11, pos21)
        self.assertAlmostRelativeEquals(pos12, pos22)
        self.assertAlmostRelativeEquals(posmerger1[0], posmerger2[0], 4)
        self.assertAlmostRelativeEquals(posmerger1[1], posmerger2[1], 1)
Ejemplo n.º 8
0
    def test11(self):
        instance = Mikkola()

        self.assertTrue(instance.parameters.evolve_to_exact_time)
        instance.parameters.evolve_to_exact_time = False
        self.assertFalse(instance.parameters.evolve_to_exact_time)

        self.assertEqual(instance.parameters.maximum_number_of_particles, 100)
        instance.parameters.maximum_number_of_particles = 200
        self.assertEqual(instance.parameters.maximum_number_of_particles, 200)

        self.assertAlmostRelativeEquals(instance.parameters.tolerance, 1e-13,
                                        6)
        instance.parameters.tolerance = 1e-10
        self.assertAlmostRelativeEquals(instance.parameters.tolerance, 1e-10)

        instance.stop()
Ejemplo n.º 9
0
 def test11(self):
     instance = Mikkola()
     
     self.assertTrue(instance.parameters.evolve_to_exact_time)
     instance.parameters.evolve_to_exact_time = False
     self.assertFalse(instance.parameters.evolve_to_exact_time)
     
     self.assertEquals(instance.parameters.maximum_number_of_particles, 100)
     instance.parameters.maximum_number_of_particles = 200
     self.assertEquals(instance.parameters.maximum_number_of_particles, 200)
     
     
     self.assertAlmostRelativeEquals(instance.parameters.tolerance, 1e-13, 6)
     instance.parameters.tolerance = 1e-10
     self.assertAlmostRelativeEquals(instance.parameters.tolerance, 1e-10)
     
     instance.stop()