Example #1
0
 def test9(self):
     print "Test CollisionHandler with gravity code and StickySpheres collision code"
     gravity = GravityCodeForTesting()
     self.assertEqual(len(gravity.particles), 6)
     gravity.particles.mass = [1, 1, 2, 2, 3, 3,] | units.MSun
     gravity.particles.radius = range(101, 107) | units.RSun
     
     collision_code = StickySpheres(mass_loss=0.1)
     
     handler = CollisionHandler(
         collision_code, 
         gravity_code=gravity
     )
     merged = handler.handle_collisions(gravity.particles[::2], gravity.particles[1::2])
     self.assertTrue(isinstance(merged, Particles))
     self.assertEqual(len(merged), 3)
     self.assertEqual(merged.mass, 0.9 * ([2, 4, 6] | units.MSun))
     
     self.assertEqual(len(gravity.particles), 3)
     self.assertEqual(gravity.particles.mass, 0.9 * ([2, 4, 6] | units.MSun))
     self.assertEqual(gravity.particles.radius, [102, 104, 106] | units.RSun)
     self.assertAlmostEqual(gravity.particles.position, 
         [[0.5, 1.0, 1.5], [2.5, 5.0, 7.5], [4.5, 9.0, 13.5]] | units.AU)
     self.assertAlmostEqual(gravity.particles.velocity, 
         [[0.5, 0.5, 0.5], [2.5, 6.5, 17.5], [4.5, 20.5, 94.5]] | units.km / units.s)
    def test9(self):
        print "Test CollisionHandler with gravity code and StickySpheres collision code"
        gravity = GravityCodeForTesting()
        self.assertEqual(len(gravity.particles), 6)
        gravity.particles.mass = [
            1,
            1,
            2,
            2,
            3,
            3,
        ] | units.MSun
        gravity.particles.radius = range(101, 107) | units.RSun

        collision_code = StickySpheres(mass_loss=0.1)

        handler = CollisionHandler(collision_code, gravity_code=gravity)
        merged = handler.handle_collisions(gravity.particles[::2],
                                           gravity.particles[1::2])
        self.assertTrue(isinstance(merged, Particles))
        self.assertEqual(len(merged), 3)
        self.assertEqual(merged.mass, 0.9 * ([2, 4, 6] | units.MSun))

        self.assertEqual(len(gravity.particles), 3)
        self.assertEqual(gravity.particles.mass,
                         0.9 * ([2, 4, 6] | units.MSun))
        self.assertEqual(gravity.particles.radius,
                         [102, 104, 106] | units.RSun)
        self.assertAlmostEqual(
            gravity.particles.position,
            [[0.5, 1.0, 1.5], [2.5, 5.0, 7.5], [4.5, 9.0, 13.5]] | units.AU)
        self.assertAlmostEqual(
            gravity.particles.velocity,
            [[0.5, 0.5, 0.5], [2.5, 6.5, 17.5], [4.5, 20.5, 94.5]]
            | units.km / units.s)
    def test7(self):
        print "Test CollisionHandler with stellar evolution code, type II"
        stellar_evolution = StellarEvolutionCodeWithInternalStructureForTesting(
        )
        self.assertEqual(len(stellar_evolution.particles), 6)
        self.assertEqual(stellar_evolution.particles.type, ["native star"] * 6)

        collision_code = CollisionCodeForTesting()
        collision_code.stellar_evolution_code_required = True

        self.assertRaises(
            AmuseException,
            CollisionHandler,
            collision_code,
            expected_message=
            "CollisionCodeForTesting requires a stellar evolution code: "
            "CollisionHandler(..., stellar_evolution_code=x)")

        handler = CollisionHandler(collision_code,
                                   stellar_evolution_code=stellar_evolution)
        merged = handler.handle_collisions(stellar_evolution.particles[::2],
                                           stellar_evolution.particles[1::2])
        self.assertTrue(isinstance(merged, Particles))
        self.assertEqual(len(merged), 3)
        self.assertEqual(merged.mass, [1, 2, 3] | units.kg)

        self.assertEqual(len(stellar_evolution.particles), 3)
        self.assertEqual(stellar_evolution.particles.mass,
                         [1, 2, 3] | units.kg)
        self.assertEqual(stellar_evolution.particles.radius,
                         [3, 7, 11] | units.RSun)
        self.assertEqual(stellar_evolution.particles.type,
                         ["new particle from model"] * 3)
Example #4
0
 def test4(self):
     print "Test handle_collisions"
     colliders = Particles(8)
     handler = CollisionHandler(CollisionCodeForTesting)
     
     result = handler.handle_collisions(colliders[:4], colliders[4:])
     self.assertTrue(isinstance(result, Particles))
     self.assertEqual(len(result), 4)
     self.assertEqual(result.mass, [1, 1, 1, 1] | units.kg)
    def test4(self):
        print "Test handle_collisions"
        colliders = Particles(8)
        handler = CollisionHandler(CollisionCodeForTesting)

        result = handler.handle_collisions(colliders[:4], colliders[4:])
        self.assertTrue(isinstance(result, Particles))
        self.assertEqual(len(result), 4)
        self.assertEqual(result.mass, [1, 1, 1, 1] | units.kg)
    def test8(self):
        print "Test CollisionHandler with stellar evolution and gravity code"
        gravity = GravityCodeForTesting()
        self.assertEqual(len(gravity.particles), 6)

        stellar_evolution = StellarEvolutionCodeForTesting(
            particles=gravity.particles.copy())
        self.assertEqual(len(stellar_evolution.particles), 6)

        collision_code = CollisionCodeForTesting()
        collision_code.stellar_evolution_code_required = True

        self.assertRaises(
            AmuseException,
            CollisionHandler,
            collision_code,
            expected_message=
            "CollisionCodeForTesting requires a stellar evolution code: "
            "CollisionHandler(..., stellar_evolution_code=x)")

        handler = CollisionHandler(collision_code,
                                   stellar_evolution_code=stellar_evolution,
                                   gravity_code=gravity)
        merged = handler.handle_collisions(stellar_evolution.particles[::2],
                                           stellar_evolution.particles[1::2])
        self.assertTrue(isinstance(merged, Particles))
        self.assertEqual(len(merged), 3)
        self.assertEqual(merged.mass, [1, 2, 3] | units.kg)

        self.assertEqual(len(stellar_evolution.particles), 3)
        self.assertEqual(stellar_evolution.particles.mass,
                         [1, 2, 3] | units.kg)
        self.assertEqual(stellar_evolution.particles.radius,
                         [3, 7, 11] | units.RSun)

        self.assertEqual(len(gravity.particles), 3)
        self.assertEqual(gravity.particles.mass, [1, 2, 3] | units.kg)
        self.assertEqual(gravity.particles.radius, [3, 7, 11] | units.RSun)
        self.assertAlmostEqual(
            gravity.particles.position,
            [[0.5, 1.0, 1.5], [2.5, 5.0, 7.5], [4.5, 9.0, 13.5]] | units.AU)
        self.assertAlmostEqual(
            gravity.particles.velocity,
            [[0.5, 0.5, 0.5], [2.5, 6.5, 17.5], [4.5, 20.5, 94.5]]
            | units.km / units.s)
Example #7
0
 def test5(self):
     print "Test CollisionHandler with gravity code"
     gravity = GravityCodeForTesting()
     self.assertEqual(len(gravity.particles), 6)
     
     handler = CollisionHandler(CollisionCodeForTesting, gravity_code=gravity)
     merged = handler.handle_collisions(gravity.particles[::2], gravity.particles[1::2])
     self.assertTrue(isinstance(merged, Particles))
     self.assertEqual(len(merged), 3)
     self.assertEqual(merged.mass, [1, 1, 1] | units.kg)
     
     self.assertEqual(len(gravity.particles), 3)
     self.assertEqual(gravity.particles.mass, [1, 1, 1] | units.kg)
     self.assertEqual(gravity.particles.radius, [3, 3, 3] | units.RSun)
     self.assertAlmostEqual(gravity.particles.position, 
         [[0.5, 1.0, 1.5], [2.5, 5.0, 7.5], [4.5, 9.0, 13.5]] | units.AU)
     self.assertAlmostEqual(gravity.particles.velocity, 
         [[0.5, 0.5, 0.5], [2.5, 6.5, 17.5], [4.5, 20.5, 94.5]] | units.km / units.s)
 def test5(self):
     print "Test CollisionHandler with gravity code"
     gravity = GravityCodeForTesting()
     self.assertEqual(len(gravity.particles), 6)
     
     handler = CollisionHandler(CollisionCodeForTesting, gravity_code=gravity)
     merged = handler.handle_collisions(gravity.particles[::2], gravity.particles[1::2])
     self.assertTrue(isinstance(merged, Particles))
     self.assertEqual(len(merged), 3)
     self.assertEqual(merged.mass, [1, 1, 1] | units.kg)
     
     self.assertEqual(len(gravity.particles), 3)
     self.assertEqual(gravity.particles.mass, [1, 1, 1] | units.kg)
     self.assertEqual(gravity.particles.radius, [3, 3, 3] | units.RSun)
     self.assertAlmostEqual(gravity.particles.position, 
         [[0.5, 1.0, 1.5], [2.5, 5.0, 7.5], [4.5, 9.0, 13.5]] | units.AU)
     self.assertAlmostEqual(gravity.particles.velocity, 
         [[0.5, 0.5, 0.5], [2.5, 6.5, 17.5], [4.5, 20.5, 94.5]] | units.km / units.s)
Example #9
0
 def test6(self):
     print "Test CollisionHandler with stellar evolution code, type I"
     stellar_evolution = StellarEvolutionCodeForTesting()
     self.assertEqual(len(stellar_evolution.particles), 6)
     
     collision_code = CollisionCodeForTesting()
     collision_code.stellar_evolution_code_required = True
     
     self.assertRaises(AmuseException, CollisionHandler, collision_code, expected_message=
          "CollisionCodeForTesting requires a stellar evolution code: "
          "CollisionHandler(..., stellar_evolution_code=x)")
     
     handler = CollisionHandler(collision_code, stellar_evolution_code=stellar_evolution)
     merged = handler.handle_collisions(stellar_evolution.particles[::2], stellar_evolution.particles[1::2])
     self.assertTrue(isinstance(merged, Particles))
     self.assertEqual(len(merged), 3)
     self.assertEqual(merged.mass, [1, 2, 3] | units.kg)
     
     self.assertEqual(len(stellar_evolution.particles), 3)
     self.assertEqual(stellar_evolution.particles.mass, [1, 2, 3] | units.kg)
     self.assertEqual(stellar_evolution.particles.radius, [3, 7, 11] | units.RSun)
Example #10
0
 def test8(self):
     print "Test CollisionHandler with stellar evolution and gravity code"
     gravity = GravityCodeForTesting()
     self.assertEqual(len(gravity.particles), 6)
     
     stellar_evolution = StellarEvolutionCodeForTesting(particles=gravity.particles.copy())
     self.assertEqual(len(stellar_evolution.particles), 6)
     
     collision_code = CollisionCodeForTesting()
     collision_code.stellar_evolution_code_required = True
     
     self.assertRaises(AmuseException, CollisionHandler, collision_code, expected_message=
          "CollisionCodeForTesting requires a stellar evolution code: "
          "CollisionHandler(..., stellar_evolution_code=x)")
     
     handler = CollisionHandler(
         collision_code, 
         stellar_evolution_code=stellar_evolution, 
         gravity_code=gravity
     )
     merged = handler.handle_collisions(stellar_evolution.particles[::2], stellar_evolution.particles[1::2])
     self.assertTrue(isinstance(merged, Particles))
     self.assertEqual(len(merged), 3)
     self.assertEqual(merged.mass, [1, 2, 3] | units.kg)
     
     self.assertEqual(len(stellar_evolution.particles), 3)
     self.assertEqual(stellar_evolution.particles.mass, [1, 2, 3] | units.kg)
     self.assertEqual(stellar_evolution.particles.radius, [3, 7, 11] | units.RSun)
     
     self.assertEqual(len(gravity.particles), 3)
     self.assertEqual(gravity.particles.mass, [1, 2, 3] | units.kg)
     self.assertEqual(gravity.particles.radius, [3, 7, 11] | units.RSun)
     self.assertAlmostEqual(gravity.particles.position, 
         [[0.5, 1.0, 1.5], [2.5, 5.0, 7.5], [4.5, 9.0, 13.5]] | units.AU)
     self.assertAlmostEqual(gravity.particles.velocity, 
         [[0.5, 0.5, 0.5], [2.5, 6.5, 17.5], [4.5, 20.5, 94.5]] | units.km / units.s)