Exemple #1
0
 def test9(self):
     print "Test SmallNInterface evolve_model"
     instance = SmallNInterface()
     self.assertEquals(0, instance.initialize_code())
     self.assertEquals(0, instance.set_eta(0.001))
     self.assertEquals(0, instance.commit_parameters())
     
     # Set up an equal-mass binary on a circular orbit:
     self.assertEquals([1, 0], instance.new_particle(0.5,  0.5, 0, 0,  0, 0.5, 0, 0.01).values())
     self.assertEquals([2, 0], instance.new_particle(0.5,  -0.5, 0, 0,  0,-0.5, 0, 0.01).values())
     self.assertEquals(0, instance.commit_particles())
     
     self.assertEquals(0, instance.evolve_model(math.pi))
     for result, expected in zip(instance.get_position(1).values(), [-0.5, 0.0, 0.0, 0]):
         self.assertAlmostEquals(result, expected, 3)
     for result, expected in zip(instance.get_position(2).values(), [0.5, 0.0, 0.0, 0]):
         self.assertAlmostEquals(result, expected, 3)
     
     self.assertEquals(0, instance.evolve_model(2 * math.pi))
     #print instance.get_time()
     #print instance.get_position(1), instance.get_velocity(1)
     #print instance.get_position(2)
     #for result, expected in zip(instance.get_position(1).values(), [0.5, 0.0, 0.0, 0]):
     #    self.assertAlmostEquals(result, expected, 3)
     #for result, expected in zip(instance.get_position(2).values(), [-0.5, 0.0, 0.0, 0]):
     #    self.assertAlmostEquals(result, expected, 3)
     
     self.assertEquals(0, instance.cleanup_code())
     instance.stop()
Exemple #2
0
    def xtest8(self):
        instance = SmallNInterface()
        instance.initialize_code()
        instance.commit_parameters()
        id1, errorcode = instance.new_particle(mass=10.0,
                                               radius=1.0,
                                               x=0.0,
                                               y=0.0,
                                               z=0.0,
                                               vx=0.0,
                                               vy=0.0,
                                               vz=0.0)
        id2, errorcode = instance.new_particle(mass=1.0,
                                               radius=1.0,
                                               x=2.0,
                                               y=0.0,
                                               z=0.0,
                                               vx=10.0,
                                               vy=0.0,
                                               vz=0.0)

        instance.commit_particles()
        potential, errorcode = instance.get_potential(id1)
        self.assertEqual(errorcode, 0)
        self.assertAlmostRelativeEquals(potential, -1.0 / numpy.sqrt(2.0**2),
                                        8)
        total_potential, errorcode = instance.get_potential_energy()
        potentials, errorcode = instance.get_potential([id1, id2])
        instance.cleanup_code()
        instance.stop()

        self.assertAlmostRelativeEquals(
            total_potential,
            numpy.sum(potentials * [10.0, 1.0]) / 2.0)
Exemple #3
0
    def test9(self):
        print "Test SmallNInterface evolve_model"
        instance = SmallNInterface()
        self.assertEquals(0, instance.initialize_code())
        self.assertEquals(0, instance.set_eta(0.001))
        self.assertEquals(0, instance.commit_parameters())

        # Set up an equal-mass binary on a circular orbit:
        self.assertEquals([1, 0],
                          instance.new_particle(0.5, 0.5, 0, 0, 0, 0.5, 0,
                                                0.01).values())
        self.assertEquals([2, 0],
                          instance.new_particle(0.5, -0.5, 0, 0, 0, -0.5, 0,
                                                0.01).values())
        self.assertEquals(0, instance.commit_particles())

        self.assertEquals(0, instance.evolve_model(math.pi))
        for result, expected in zip(
                instance.get_position(1).values(), [-0.5, 0.0, 0.0, 0]):
            self.assertAlmostEquals(result, expected, 3)
        for result, expected in zip(
                instance.get_position(2).values(), [0.5, 0.0, 0.0, 0]):
            self.assertAlmostEquals(result, expected, 3)

        self.assertEquals(0, instance.evolve_model(2 * math.pi))
        #print instance.get_time()
        #print instance.get_position(1), instance.get_velocity(1)
        #print instance.get_position(2)
        #for result, expected in zip(instance.get_position(1).values(), [0.5, 0.0, 0.0, 0]):
        #    self.assertAlmostEquals(result, expected, 3)
        #for result, expected in zip(instance.get_position(2).values(), [-0.5, 0.0, 0.0, 0]):
        #    self.assertAlmostEquals(result, expected, 3)

        self.assertEquals(0, instance.cleanup_code())
        instance.stop()
Exemple #4
0
 def test6(self):
     smalln = SmallNInterface()
     smalln.initialize_code()
     
     smalln.new_particle([10,10],[-1,1],[0,0], [0,0], [0,0], [0,0], [0,0], [1,1])
     retrieved_state = smalln.get_state(1)
     
     self.assertFalse(hasattr(smalln, 'get_potential_at_point'))
     #retr = smalln.get_potential_at_point(0.01, 0, 0, 0)
     #self.assertEqual(retr['__result'], -1)
     smalln.cleanup_code()
     smalln.stop()
Exemple #5
0
    def test6(self):
        smalln = SmallNInterface()
        smalln.initialize_code()

        smalln.new_particle([10, 10], [-1, 1], [0, 0], [0, 0], [0, 0], [0, 0],
                            [0, 0], [1, 1])
        retrieved_state = smalln.get_state(1)

        self.assertFalse(hasattr(smalln, 'get_potential_at_point'))
        #retr = smalln.get_potential_at_point(0.01, 0, 0, 0)
        #self.assertEqual(retr['__result'], -1)
        smalln.cleanup_code()
        smalln.stop()
Exemple #6
0
 def test5(self):
     smalln = SmallNInterface()
     smalln.initialize_code()
     
     smalln.new_particle([10,20],[0,0],[0,0], [0,0], [0,0], [0,0], [0,0],[1,1])
     retrieved_state = smalln.get_state(1)
     
     self.assertEquals(10.0,  retrieved_state['mass'])
     self.assertEquals(1, retrieved_state['radius'])
 
     retrieved_state = smalln.get_state([1,2])
     self.assertEquals(20.0,  retrieved_state['mass'][1])
     self.assertEquals(smalln.get_number_of_particles()['number_of_particles'], 2)
     smalln.cleanup_code() 
     smalln.stop()
Exemple #7
0
    def test2(self):
        instance = SmallNInterface()
        instance.initialize_code()
        self.skip("index of the next particle not implemented correctly yet")
        for i in [0, 1, 2]:
            temp_particle = instance.new_particle(mass=i,
                                                  radius=1.0,
                                                  x=0.0,
                                                  y=0.0,
                                                  z=0.0,
                                                  vx=0.0,
                                                  vy=0.0,
                                                  vz=0.0)
            self.assertEqual(i + 1, temp_particle['index_of_the_particle'])

        instance.delete_particle(2)

        self.assertEqual(
            2,
            instance.get_number_of_particles()['number_of_particles'])

        self.assertEqual(
            1,
            instance.get_index_of_first_particle()['index_of_the_particle'])

        self.assertEqual(
            2,
            instance.get_index_of_next_particle(1)
            ['index_of_the_next_particle'])
        self.assertEqual(0, instance.get_index_of_next_particle(1)['__result'])
        self.assertEqual(-1,
                         instance.get_index_of_next_particle(3)['__result'])
        self.assertEqual(1, instance.get_index_of_next_particle(2)['__result'])
        instance.cleanup_code()
        instance.stop()
Exemple #8
0
    def test5(self):
        smalln = SmallNInterface()
        smalln.initialize_code()

        smalln.new_particle([10, 20], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0],
                            [0, 0], [1, 1])
        retrieved_state = smalln.get_state(1)

        self.assertEqual(10.0, retrieved_state['mass'])
        self.assertEqual(1, retrieved_state['radius'])

        retrieved_state = smalln.get_state([1, 2])
        self.assertEqual(20.0, retrieved_state['mass'][1])
        self.assertEqual(
            smalln.get_number_of_particles()['number_of_particles'], 2)
        smalln.cleanup_code()
        smalln.stop()
Exemple #9
0
 def test1(self):
     instance = SmallNInterface()
     instance.initialize_code()
 
     res1 = instance.new_particle(mass = 11.0, radius = 2.0, x = 0.0, y = 0.0, z = 0.0, vx = 0.0, vy = 0.0, vz = 0.0)
     res2 = instance.new_particle(mass = 21.0, radius = 5.0, x = 10.0, y = 0.0, z = 0.0, vx = 10.0, vy = 0.0, vz = 0.0)
     
     self.assertEquals(1, res1['index_of_the_particle'])
     self.assertEquals(2, res2['index_of_the_particle'])
 
     retrieved_state1 = instance.get_state(1)
     retrieved_state2 = instance.get_state(2)
 
     self.assertEquals(11.0,  retrieved_state1['mass'])
     self.assertEquals(21.0,  retrieved_state2['mass'])
     self.assertEquals(0.0,  retrieved_state1['x'])
     self.assertEquals(10.0,  retrieved_state2['x'])
     self.assertEquals(2.0,  retrieved_state1['radius'])
     self.assertEquals(5.0,  retrieved_state2['radius'])
 
     instance.cleanup_code()
     instance.stop()
Exemple #10
0
 def xtest7(self):
     instance = SmallNInterface()
     instance.initialize_code()
     instance.set_eps2(0.1 * 0.1)
     instance.commit_parameters()
     id1,errorcode = instance.new_particle(mass = 10.0, radius = 1.0, x = 0.0, y = 0.0, z = 0.0, vx = 0.0, vy = 0.0, vz = 0.0)
     id2,errorcode = instance.new_particle(mass = 10.0, radius = 1.0, x = 2.0, y = 0.0, z = 0.0, vx = 10.0, vy = 0.0, vz = 0.0)
     
     instance.commit_particles()
     potential, errorcode = instance.get_potential(id1)
     self.assertEquals(errorcode, 0)
     self.assertAlmostRelativeEquals(potential,  -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
     
     potential, errorcode = instance.get_potential(id2)
     self.assertEquals(errorcode, 0)
     self.assertAlmostRelativeEquals(potential,  -10.0 / numpy.sqrt(2.0**2 + 0.1**2), 8)
     
     total_potential, errorcode = instance.get_potential_energy()
     potentials, errorcode = instance.get_potential([id1, id2])
     instance.stop()
     
     self.assertAlmostRelativeEquals(total_potential, numpy.sum(potentials * [10.0, 10.0]) / 2.0)
Exemple #11
0
    def test1(self):
        instance = SmallNInterface()
        instance.initialize_code()

        res1 = instance.new_particle(mass=11.0,
                                     radius=2.0,
                                     x=0.0,
                                     y=0.0,
                                     z=0.0,
                                     vx=0.0,
                                     vy=0.0,
                                     vz=0.0)
        res2 = instance.new_particle(mass=21.0,
                                     radius=5.0,
                                     x=10.0,
                                     y=0.0,
                                     z=0.0,
                                     vx=10.0,
                                     vy=0.0,
                                     vz=0.0)

        self.assertEqual(1, res1['index_of_the_particle'])
        self.assertEqual(2, res2['index_of_the_particle'])

        retrieved_state1 = instance.get_state(1)
        retrieved_state2 = instance.get_state(2)

        self.assertEqual(11.0, retrieved_state1['mass'])
        self.assertEqual(21.0, retrieved_state2['mass'])
        self.assertEqual(0.0, retrieved_state1['x'])
        self.assertEqual(10.0, retrieved_state2['x'])
        self.assertEqual(2.0, retrieved_state1['radius'])
        self.assertEqual(5.0, retrieved_state2['radius'])

        instance.cleanup_code()
        instance.stop()
Exemple #12
0
 def test2(self):
     instance = SmallNInterface()
     instance.initialize_code()
     self.skip("index of the next particle not implemented correctly yet")
     for i in [0, 1, 2]:
         temp_particle = instance.new_particle(mass = i, radius = 1.0, x = 0.0, y = 0.0, z = 0.0, vx = 0.0, vy = 0.0, vz = 0.0)
         self.assertEquals(i+1, temp_particle['index_of_the_particle'])
         
     instance.delete_particle(2)
   
     self.assertEquals(2, instance.get_number_of_particles()['number_of_particles'])
     
     self.assertEquals(1, instance.get_index_of_first_particle()['index_of_the_particle'])
     
     self.assertEquals(2, instance.get_index_of_next_particle(1)['index_of_the_next_particle'])
     self.assertEquals(0, instance.get_index_of_next_particle(1)['__result'])
     self.assertEquals(-1, instance.get_index_of_next_particle(3)['__result'])
     self.assertEquals(1, instance.get_index_of_next_particle(2)['__result'])
     instance.stop()