def test8(self):
random.seed(1001)
print "Test 8: SI vs nbody units."
converter = nbody_system.nbody_to_si(1.0 | units.MSun,
1.0 | units.RSun)
numpy.random.seed(1234)
particles = new_plummer_model(1000, convert_nbody=converter)
hop = Hop(unit_converter=converter)
hop.particles.add_particles(particles)
hop.calculate_densities()
hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3
hop.do_hop()
groups = list(hop.groups())
self.assertEquals(len(hop.particles), 1000)
self.assertEquals(len(groups), 1)
self.assertEquals(len(groups[0]), 511)
self.assertEquals(len(hop.no_group()), 489)
hop.stop()
numpy.random.seed(1234)
particles = new_plummer_model(1000)
hop = Hop()
hop.particles.add_particles(particles)
hop.calculate_densities()
hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3
hop.do_hop()
groups = list(hop.groups())
self.assertEquals(len(hop.particles), 1000)
self.assertEquals(len(groups), 1)
self.assertEquals(len(groups[0]), 511)
self.assertEquals(len(hop.no_group()), 489)
hop.stop()
def test7(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100, convert_nbody = self.nbody_converter)
new_particles = new_plummer_model(50, convert_nbody = self.nbody_converter)
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEquals(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.remove_particle(particles[40])
instance.particles.remove_particle(particles[70])
instance.particles.add_particle(new_particles[0])
print new_particles[0].key
instance.recommit_particles()
# test the get_mass, get_position and get_velocity functions
# if they are implemented for the code, otherwise will call
# get_state multiple times
# todo, fi fails, need to check with inti
#self.assertAlmostRelativeEqual(instance.particles[-1].mass, new_particles[0].mass)
#self.assertAlmostRelativeEqual(instance.particles[-1].velocity, new_particles[0].velocity)
#self.assertAlmostRelativeEqual(instance.particles[-1].position, new_particles[0].position)
instance.particles.synchronize_to(particles)
self.assertEquals(len(particles), 99)
self.assertEquals(particles[-1], new_particles[0])
finally:
instance.stop()
def test7(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100, convert_nbody = self.nbody_converter)
new_particles = new_plummer_model(50, convert_nbody = self.nbody_converter)
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEquals(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.remove_particle(particles[40])
instance.particles.remove_particle(particles[70])
instance.particles.add_particle(new_particles[0])
print new_particles[0].key
instance.recommit_particles()
# test the get_mass, get_position and get_velocity functions
# if they are implemented for the code, otherwise will call
# get_state multiple times
# todo, fi fails, need to check with inti
#self.assertAlmostRelativeEqual(instance.particles[-1].mass, new_particles[0].mass)
#self.assertAlmostRelativeEqual(instance.particles[-1].velocity, new_particles[0].velocity)
#self.assertAlmostRelativeEqual(instance.particles[-1].position, new_particles[0].position)
instance.particles.synchronize_to(particles)
self.assertEquals(len(particles), 99)
self.assertEquals(particles[-1], new_particles[0])
finally:
instance.stop()
def test3(self):
random.seed(1001)
print "Third test: densest neighbors and groups."
hop = HopInterface()
hop.initialize_code()
particles1 = new_plummer_model(10)
particles2 = new_plummer_model(10)
particles3 = new_plummer_model(10)
particles2.position += (10, 0, 0) | nbody_system.length
particles3.position += (0, 20, 0) | nbody_system.length
ids1, errors = hop.new_particle(
particles1.mass.value_in(nbody_system.mass),
particles1.x.value_in(nbody_system.length),
particles1.y.value_in(nbody_system.length),
particles1.z.value_in(nbody_system.length))
ids2, errors = hop.new_particle(
particles2.mass.value_in(nbody_system.mass),
particles2.x.value_in(nbody_system.length),
particles2.y.value_in(nbody_system.length),
particles2.z.value_in(nbody_system.length))
ids3, errors = hop.new_particle(
particles3.mass.value_in(nbody_system.mass),
particles3.x.value_in(nbody_system.length),
particles3.y.value_in(nbody_system.length),
particles3.z.value_in(nbody_system.length))
hop.set_nDens(5)
hop.calculate_densities()
hop.do_hop()
n, err = hop.get_group_id(ids1)
self.assertEquals(n, 2)
self.assertEquals(err, 0)
n, err = hop.get_group_id(ids2)
self.assertEquals(err, 0)
n, err = hop.get_group_id(ids3)
self.assertEquals(err, 0)
n, err = hop.get_densest_particle_in_group(2)
self.assertEquals(n, 7)
for i in range(3):
n, err = hop.get_number_of_particles_in_group(0)
self.assertEquals(err, 0)
self.assertEquals(n, 10)
n, err = hop.get_number_of_groups()
self.assertEquals(n, 3)
n, err = hop.get_densest_neighbor(ids1)
self.assertEquals(n, [7, 7, 12, 0, 7, 7, 7, 7, 12, 7])
hop.stop()
def test2(self):
seed(1)
particles=new_plummer_model(10000)
instance = Agama(type="Multipole", particles=particles)
result=instance.get_potential_at_point(
0.|generic_unit_system.length,
0.|generic_unit_system.length,
0.|generic_unit_system.length,
0.|generic_unit_system.length)
self.assertLess(abs(result/(-16./3/3.1416|
generic_unit_system.length**2/generic_unit_system.time**2) - 1), 0.04)
scaleM=1234|units.MSun
scaleR=5.6 |units.parsec
converter=nbody_system.nbody_to_si(scaleM,scaleR)
particles=new_plummer_model(20000, convert_nbody=converter)
instance = Agama(converter, type="Multipole", particles=particles)
x=3.|units.parsec
y=4.|units.parsec
z=5.|units.parsec
r=(x*x+y*y+z*z)**0.5
result=instance.get_gravity_at_point(0|units.parsec, x, y, z)
expected=-constants.G*scaleM/(r*r+(3*3.1416/16*scaleR)**2)**1.5*x
self.assertLess(abs(result[0]/expected-1), 0.03)
self.assertLess(abs(result[2]/result[0]-z/x), 0.03)
instance.stop()
def test4(self):
numpy.random.seed(12345)
plummer = new_plummer_model(100)
fastkick = self.new_fastkick_instance()
fastkick.initialize_code()
fastkick.particles.add_particles(plummer)
points = new_plummer_model(73)
potential1 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax1, ay1, az1 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
fastkick.reset()
potential0 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax0, ay0, az0 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
self.assertAlmostEqual(potential0, 0 | nbody_system.potential)
self.assertAlmostEqual(ax0, 0 | nbody_system.acceleration)
self.assertAlmostEqual(ay0, 0 | nbody_system.acceleration)
self.assertAlmostEqual(az0, 0 | nbody_system.acceleration)
fastkick.reset()
for p in plummer:
fastkick.particles.add_particle(p)
potential2 = fastkick.get_potential_at_point(0*points.x, points.x, points.y, points.z)
ax2, ay2, az2 = fastkick.get_gravity_at_point(0*points.x, points.x, points.y, points.z)
self.assertAlmostEqual(potential1, potential2, 5)
self.assertAlmostEqual(ax1, ax2, 5)
self.assertAlmostEqual(ay1, ay2, 5)
self.assertAlmostEqual(az1, az2, 5)
fastkick.cleanup_code()
fastkick.stop()
def test6(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100, convert_nbody = self.nbody_converter)
more_particles = new_plummer_model(50, convert_nbody = self.nbody_converter)
particles.radius = 0 | self.length_unit
more_particles.radius = 1.0 | self.length_unit
particles.move_to_center()
more_particles.move_to_center()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEquals(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.add_particles(more_particles)
instance.recommit_particles()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles']
self.assertEquals(len(instance.particles), 150)
self.assertEquals(number_of_particles_in_module, 150)
instance.synchronize_model()
instance.particles.remove_particles(particles)
self.assertEquals(len(instance.particles), 50)
instance.recommit_particles()
instance.synchronize_model()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles']
self.assertEquals(len(instance.particles), 50)
self.assertEquals(number_of_particles_in_module, 50)
finally:
instance.stop()
def test6(self):
plummer = new_plummer_model(100)
points = new_plummer_model(73)
instance = self.new_fastkick_instance(number_of_workers=1)
instance.particles.add_particles(plummer)
potential1 = instance.get_potential_at_point(0 * points.x, points.x,
points.y, points.z)
ax1, ay1, az1 = instance.get_gravity_at_point(0 * points.x, points.x,
points.y, points.z)
instance.stop()
expected_accuracy = 13 if self.mode == "cpu" else 5
number_of_workers_range = [2, 3, 4, 5] if self.mode == "cpu" else [2]
for n in number_of_workers_range:
instance = self.new_fastkick_instance(number_of_workers=n)
instance.particles.add_particles(plummer)
potential = instance.get_potential_at_point(
0 * points.x, points.x, points.y, points.z)
ax, ay, az = instance.get_gravity_at_point(0 * points.x, points.x,
points.y, points.z)
instance.stop()
self.assertAlmostEqual(potential, potential1, expected_accuracy)
self.assertAlmostEqual(ax, ax1, expected_accuracy)
self.assertAlmostEqual(ay, ay1, expected_accuracy)
self.assertAlmostEqual(az, az1, expected_accuracy)
def test4(self):
numpy.random.seed(12345)
plummer = new_plummer_model(100)
fastkick = self.new_fastkick_instance()
fastkick.initialize_code()
fastkick.particles.add_particles(plummer)
points = new_plummer_model(73)
potential1 = fastkick.get_potential_at_point(0 * points.x, points.x,
points.y, points.z)
ax1, ay1, az1 = fastkick.get_gravity_at_point(0 * points.x, points.x,
points.y, points.z)
fastkick.reset()
potential0 = fastkick.get_potential_at_point(0 * points.x, points.x,
points.y, points.z)
ax0, ay0, az0 = fastkick.get_gravity_at_point(0 * points.x, points.x,
points.y, points.z)
self.assertAlmostEqual(potential0, 0 | nbody_system.potential)
self.assertAlmostEqual(ax0, 0 | nbody_system.acceleration)
self.assertAlmostEqual(ay0, 0 | nbody_system.acceleration)
self.assertAlmostEqual(az0, 0 | nbody_system.acceleration)
fastkick.reset()
for p in plummer:
fastkick.particles.add_particle(p)
potential2 = fastkick.get_potential_at_point(0 * points.x, points.x,
points.y, points.z)
ax2, ay2, az2 = fastkick.get_gravity_at_point(0 * points.x, points.x,
points.y, points.z)
self.assertAlmostEqual(potential1, potential2, 5)
self.assertAlmostEqual(ax1, ax2, 5)
self.assertAlmostEqual(ay1, ay2, 5)
self.assertAlmostEqual(az1, az2, 5)
fastkick.cleanup_code()
fastkick.stop()
def test8(self):
random.seed(1001)
print "Test 8: SI vs nbody units."
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.RSun)
numpy.random.seed(1234)
particles = new_plummer_model(1000, convert_nbody=converter)
hop = Hop(unit_converter=converter)
hop.particles.add_particles(particles)
hop.calculate_densities()
hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3
hop.do_hop()
groups = list(hop.groups())
self.assertEquals(len(hop.particles), 1000)
self.assertEquals(len(groups), 1)
self.assertEquals(len(groups[0]), 511)
self.assertEquals(len(hop.no_group()), 489)
hop.stop()
numpy.random.seed(1234)
particles = new_plummer_model(1000)
hop = Hop()
hop.particles.add_particles(particles)
hop.calculate_densities()
hop.parameters.outer_density_threshold = 0.1 | nbody_system.mass / nbody_system.length**3
hop.do_hop()
groups = list(hop.groups())
self.assertEquals(len(hop.particles), 1000)
self.assertEquals(len(groups), 1)
self.assertEquals(len(groups[0]), 511)
self.assertEquals(len(hop.no_group()), 489)
hop.stop()
def test6(self):
factory = self.gravity_code_factory()
instance = self.new_instance_of_an_optional_code(factory)
try:
particles = new_plummer_model(100, convert_nbody = self.nbody_converter)
more_particles = new_plummer_model(50, convert_nbody = self.nbody_converter)
particles.radius = 0 | self.length_unit
more_particles.radius = 1.0 | self.length_unit
particles.move_to_center()
more_particles.move_to_center()
instance.particles.add_particles(particles)
instance.commit_particles()
self.assertEquals(len(instance.particles), 100)
instance.synchronize_model()
instance.particles.add_particles(more_particles)
instance.recommit_particles()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles']
self.assertEquals(len(instance.particles), 150)
self.assertEquals(number_of_particles_in_module, 150)
instance.synchronize_model()
instance.particles.remove_particles(particles)
self.assertEquals(len(instance.particles), 50)
instance.recommit_particles()
instance.synchronize_model()
number_of_particles_in_module = instance.legacy_interface.get_number_of_particles()['number_of_particles']
self.assertEquals(len(instance.particles), 50)
self.assertEquals(number_of_particles_in_module, 50)
finally:
instance.stop()
def test9(self):
print "Testing MI6 evolve_model and getters energy, plummer sphere, no SMBH"
converter = nbody_system.nbody_to_si(1.0e2 | units.MSun,
1.0 | units.parsec)
instance = MI6(converter, **default_options)
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.13633848369e+37 | units.J, 5)
self.assertAlmostRelativeEqual(potential_energy,
-4.34851806763e+37 | units.J, 5)
self.assertAlmostRelativeEqual(potential_energy + kinetic_energy,
initial_total_energy, 5)
instance.cleanup_code()
instance.stop()
def test2(self):
random.seed(1001)
hop = HopInterface()
hop.initialize_code()
particles = new_plummer_model(1000)
ids, errors = hop.new_particle(
particles.mass.value_in(nbody_system.mass),
particles.x.value_in(nbody_system.length),
particles.y.value_in(nbody_system.length),
particles.z.value_in(nbody_system.length))
n, err = hop.get_number_of_particles()
self.assertEquals(n, 1000)
self.assertEquals(err, 0)
#distance_to_center = (particles.position - particles.center_of_mass()).lengths()
#print distance_to_center
ds = {0: 0.482308834791, 1: 0.4885137677192688, 2: 0.27442726492881775}
for method in [0, 1, 2]:
hop.set_nDens(7)
hop.set_density_method(method)
hop.calculate_densities()
d, err = hop.get_density(0)
self.assertAlmostRelativeEquals(d, ds[method], 5)
hop.stop()
def test2(self):
random.seed(1001)
hop = Hop()
hop.initialize_code()
hop.parameters.number_of_neighbors_for_local_density = 7
hop.commit_parameters()
particles = new_plummer_model(1000)
hop.particles.add_particles(particles)
#distance_to_center = (particles.position - particles.center_of_mass()).lengths()
#print distance_to_center
ds = {0: 0.482308834791, 1: 0.4885137677192688, 2: 0.27442726492881775}
for method in [0, 1, 2]:
hop.set_density_method(method)
hop.calculate_densities()
d = hop.particles[0].density
self.assertAlmostRelativeEquals(d,
ds[method] | nbody_system.density,
5)
hop.stop()
def test13(self):
particles = plummer.new_plummer_model(31)
instance = Hermite(number_of_workers=1)#, debugger="xterm")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
positions_per_workers = []
for n in [2,3,4,5]:
instance = Hermite(number_of_workers=n)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
positions_per_workers.append(instance.particles.position)
instance.stop()
for index, n in enumerate([2,3,4,5]):
self.assertAlmostEqual(expected_positions, positions_per_workers[index], 15)
def test1(self):
plummer_size = 500
plummer = new_plummer_model(plummer_size)
mass=plummer.mass.number
radius=plummer.radius.number
x=plummer.x.number
y=plummer.y.number
z=plummer.z.number
vx=plummer.vx.number
vy=plummer.vy.number
vz=plummer.vz.number
instance = self.new_instance_of_an_optional_code(BonsaiInterface, **default_options)
self.assertEquals(0, instance.initialize_code())
self.assertEquals([0, 0], instance.get_number_of_particles().values())
ids, errors = instance.new_particle(mass,x,y,z,vx,vy,vz,radius)
self.assertEquals(0, errors)
self.assertEquals(range(plummer_size), ids)
self.assertEquals(0, instance.commit_particles())
self.assertEquals([500, 0], instance.get_number_of_particles().values())
masses, errors = instance.get_mass(range(500))
self.assertEquals(0, errors)
self.assertAlmostEquals(0.002, masses)
masses,xs,ys,zs,vxs,vys,vzs,radii, errors = instance.get_state(range(500))
self.assertEquals(0, errors)
self.assertAlmostRelativeEquals(xs, x, 6)
self.assertEquals(0, instance.evolve_model(0.00001))
energy_total_init = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"]
self.assertEquals(0, instance.evolve_model(1))
energy_total_final = instance.get_potential_energy()["potential_energy"] + instance.get_kinetic_energy()["kinetic_energy"]
self.assertAlmostRelativeEqual(energy_total_init, energy_total_final, 2)
instance.stop()
def test6(self):
print "Testing Bonsai states"
plummer = new_plummer_model(500)
print "First do everything manually:"
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(plummer)
instance.commit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
mass = instance.particles[0].mass
instance.evolve_model(0.1 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
instance.cleanup_code()
self.assertEquals(instance.get_name_of_current_state(), 'END')
instance.stop()
print ("initialize_code(), commit_parameters(), commit_particles(), and cleanup_code() should be called " +
"automatically before editing parameters, new_particle(), get_xx(), and stop():")
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
timestep = instance.parameters.timestep
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(plummer)
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.1 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
instance.stop()
self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test2(self):
random.seed(1001)
hop = HopInterface()
hop.initialize_code()
particles = new_plummer_model(1000)
ids, errors = hop.new_particle(
particles.mass.value_in(nbody_system.mass),
particles.x.value_in(nbody_system.length),
particles.y.value_in(nbody_system.length),
particles.z.value_in(nbody_system.length)
)
n, err = hop.get_number_of_particles()
self.assertEquals(n, 1000)
self.assertEquals(err, 0)
#distance_to_center = (particles.position - particles.center_of_mass()).lengths()
#print distance_to_center
ds = {0: 0.482308834791, 1:0.4885137677192688, 2:0.27442726492881775}
for method in [0,1,2]:
hop.set_nDens(7)
hop.set_density_method(method)
hop.calculate_densities()
d, err = hop.get_density(0)
self.assertAlmostRelativeEquals(d,ds[method], 5)
hop.stop()
def test5(self):
print "Testing FastKick states"
plummer = new_plummer_model(100)
print "First do everything manually:"
instance = self.new_fastkick_instance()
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.commit_parameters()
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(plummer)
instance.commit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEquals(instance.get_name_of_current_state(), 'END')
instance.stop()
print "commit_parameters(), (re)commit_particles(), and cleanup_code() should be called " \
"automatically before new_xx_particle(), get_xx(), and stop():"
instance = self.new_fastkick_instance()
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
eps = instance.parameters.epsilon_squared
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(plummer[:-1])
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
acc = instance.get_gravity_at_point(0*plummer[-1].x, plummer[-1].x, plummer[-1].y, plummer[-1].z)
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.particles.add_particle(plummer[-1])
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
acc = instance.get_gravity_at_point(0*plummer[-1].x, plummer[-1].x, plummer[-1].y, plummer[-1].z)
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test3(self):
remote=RemoteCodeInterface()
var=new_plummer_model(100)
remote.assign("var",var)
var_=remote.evaluate("var.mass")
self.assertEqual(var_,var.mass)
def test_small_plummer_model(self):
particles = plummer.new_plummer_model(31)
instance = Petar(number_of_workers=1) # , debugger="xterm")
instance.initialize_code()
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
positions_per_workers = []
for n in [2, 3, 4, 5]:
instance = Petar(number_of_workers=n)
instance.initialize_code()
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
positions_per_workers.append(instance.particles.position)
instance.stop()
for index, n in enumerate([2, 3, 4, 5]):
self.assertAlmostEqual(expected_positions,
positions_per_workers[index], 15)
def test5(self):
print "CalculateFieldForParticles get_potential_at_point, with individual softening"
epsilon = 0.5 | units.parsec
convert = nbody_system.nbody_to_si(1.0e5 | units.MSun, 1.0 | units.parsec)
numpy.random.seed(12345)
stars = new_plummer_model(100, convert_nbody=convert)
stars.radius = epsilon * numpy.random.uniform(low=0.4, high=3.0, size=len(stars))
cluster = ExampleGravityCodeInterface(softening_mode="individual")
cluster.particles.add_particles(stars)
instance = bridge.CalculateFieldForParticles(particles=stars, softening_mode="individual")
zeros = numpy.zeros(9) | units.parsec
pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec
self.assertAlmostRelativeEqual(
instance.get_potential_at_point(zeros, pos_range, zeros, zeros),
cluster.get_potential_at_point(zeros, pos_range, zeros, zeros),
)
for a_calculate_field, a_code in zip(
instance.get_gravity_at_point(zeros, pos_range, zeros, zeros),
cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros),
):
self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def test10(self):
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
stars = new_plummer_model(100)
stars.radius = 0 | nbody_system.length
instance.particles.add_particles(stars)
channel = stars.new_channel_to(instance.particles)
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.kinetic_energy + instance.potential_energy
stars.mass *= 0.9
channel.copy()
instance.synchronize_model()
e1 = instance.kinetic_energy + instance.potential_energy
delta_e = e1 - e0
self.assertTrue(e1 != e0)
instance.stop()
def test4(self):
print "CalculateFieldForParticles get_potential_at_point, with softening"
epsilon = 0.5 | units.parsec
convert = nbody_system.nbody_to_si(1.0e5 | units.MSun, 1.0 | units.parsec)
numpy.random.seed(12345)
stars = new_plummer_model(100, convert_nbody=convert)
cluster = ExampleGravityCodeInterface()
cluster.parameters.epsilon_squared = epsilon ** 2
cluster.particles.add_particles(stars)
instance = bridge.CalculateFieldForParticles(particles=stars)
instance.smoothing_length_squared = epsilon ** 2
zeros = numpy.zeros(9) | units.parsec
pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec
self.assertAlmostRelativeEqual(
instance.get_potential_at_point(zeros, pos_range, zeros, zeros),
cluster.get_potential_at_point(zeros, pos_range, zeros, zeros),
)
for a_calculate_field, a_code in zip(
instance.get_gravity_at_point(zeros, pos_range, zeros, zeros),
cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros),
):
self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def test22(self):
particles = new_plummer_model(200)
particles.scale_to_standard()
try:
instance = ph4(mode="gpu")
except:
self.skip("gpu mode is not available")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length ** 2
instance.particles.add_particles(particles)
x = numpy.arange(-1, 1, 0.1) | nbody_system.length
zero = numpy.zeros(len(x)) | nbody_system.length
gpu_potential = instance.get_potential_at_point(zero, x, zero, zero)
instance.stop()
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length ** 2
instance.particles.add_particles(particles)
nogpu_potential = instance.get_potential_at_point(zero, x, zero, zero)
self.assertAlmostRelativeEquals(nogpu_potential, gpu_potential, 5)
instance.stop()
def test16(self):
numpy.random.seed(0)
number_of_stars = 2
stars = plummer.new_plummer_model(number_of_stars)
stars.radius = 0.00001 | nbody_system.length
stars.scale_to_standard()
instance = BHTree()
instance.initialize_code()
instance.parameters.epsilon_squared = (1.0 / 20.0 /
(number_of_stars**0.33333)
| nbody_system.length)**2
instance.parameters.timestep = 0.004 | nbody_system.time
instance.parameters.timestep = 0.00001 | nbody_system.time
instance.commit_parameters()
print instance.parameters.timestep
instance.particles.add_particles(stars)
instance.commit_particles()
energy_total_t0 = instance.potential_energy + instance.kinetic_energy
request = instance.evolve_model. async (1.0 | nbody_system.time)
request.result()
energy_total_t1 = instance.potential_energy + instance.kinetic_energy
self.assertAlmostRelativeEqual(energy_total_t0, energy_total_t1, 3)
instance.stop()
numpy.random.seed()
def test13(self):
particles = plummer.new_plummer_model(31)
instance = self.new_instance_of_an_optional_code(Hacs64,
number_of_workers=1,
**default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
positions_per_workers = []
for n in [2, 3, 4, 5]:
instance = self.new_instance_of_an_optional_code(
Hacs64, number_of_workers=n, **default_options)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
positions_per_workers.append(instance.particles.position)
instance.stop()
for index, n in enumerate([2, 3, 4, 5]):
self.assertAlmostEqual(expected_positions,
positions_per_workers[index], 15)
def test7(self):
print "Testing Pikachu states"
stars = new_plummer_model(100)
black_hole = Particle()
black_hole.mass = 1.0 | nbody_system.mass
black_hole.radius = 0.0 | nbody_system.length
black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length
black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
print "First do everything manually:"
instance = self.new_instance_of_an_optional_code(
Pikachu, **default_options)
self.assertEquals(instance.get_name_of_current_state(),
'UNINITIALIZED')
instance.initialize_code()
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
#~ instance.parameters.rcut_out_star_star = 1.0 | nbody_system.length
instance.parameters.timestep = 0.001 | nbody_system.time
instance.commit_parameters()
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
instance.recommit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
instance.synchronize_model()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEquals(instance.get_name_of_current_state(), 'END')
instance.stop()
print "initialize_code(), commit_parameters(), (re)commit_particles(), " \
"synchronize_model(), and cleanup_code() should be called " \
"automatically before editing parameters, new_particle(), get_xx(), and stop():"
instance = self.new_instance_of_an_optional_code(
Pikachu, **default_options)
self.assertEquals(instance.get_name_of_current_state(),
'UNINITIALIZED')
instance.parameters.timestep = 0.001 | nbody_system.time
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test_kepler(N=10000, tend=1.| units.yr,method=0):
numpy.random.seed(12345)
conv=nbody_system.nbody_to_si(2.| units.MSun, 5.|units.AU)
comets=new_plummer_model(N,conv)
sun=Particle(mass=1.|units.MSun)
sun.position=[0,0,0]|units.AU
sun.velocity=[0,0,0]|units.kms
comets.mass*=0.
code=Kepler(conv,redirection="none")
code.set_method(method)
code.central_particle.add_particle(sun)
code.orbiters.add_particles(comets)
a0,eps0=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z,
code.orbiters.vx,code.orbiters.vy,code.orbiters.vz)
# print code.orbiters.x[0]
print orbital_elements_from_binary(code.particles[0:2],constants.G)
t1=time.time()
code.evolve_model(tend)
t2=time.time()
print orbital_elements_from_binary(code.particles[0:2],constants.G)
# print code.orbiters.x[0]
a,eps=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z,
code.orbiters.vx,code.orbiters.vy,code.orbiters.vz)
da=abs((a-a0)/a0)
deps=abs(eps-eps0)/eps0
dev=numpy.where(da > 0.00001)[0]
print len(dev)
print a0[dev].value_in(units.AU)
print eps0[dev]
# pyplot.plot(a0[dev].value_in(units.AU),eps0[dev],"ro")
# pyplot.plot(a[dev].value_in(units.AU),eps[dev],"g+")
print "max da,deps:",da.max(), deps.max()
print "time:",t2-t1
# pyplot.show()
return t2-t1,da.max(),deps.max()
def test9(self):
print "Testing MI6 evolve_model and getters energy, plummer sphere, no SMBH"
converter = nbody_system.nbody_to_si(1.0e2 | units.MSun, 1.0 | units.parsec)
instance = MI6(converter, **default_options)
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.13633848369e+37 | units.J, 5)
self.assertAlmostRelativeEqual(potential_energy, -4.34851806763e+37 | units.J, 5)
self.assertAlmostRelativeEqual(potential_energy + kinetic_energy, initial_total_energy, 5)
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.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 test10b(self):
instance = ph4(number_of_workers=4)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.timestep_parameter = 0.01
stars = new_plummer_model(100)
instance.particles.add_particles(stars)
channel = stars.new_channel_to(instance.particles)
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.kinetic_energy + instance.potential_energy
stars.mass *= 0.9
channel.copy()
instance.synchronize_model()
e1 = instance.kinetic_energy + instance.potential_energy
instance.cleanup_code()
instance.stop()
delta_e = e1 - e0
self.assertTrue(e1 != e0)
def test5(self):
print "Test error codes"
unit_converter = nbody_system.nbody_to_si(1.0 | units.MSun,
1.0 | units.AU)
particles = new_plummer_model(200, convert_nbody=unit_converter)
hop = Hop(unit_converter=unit_converter) #, redirection="none")
hop.parameters.number_of_neighbors_for_local_density = 100
hop.particles.add_particles(particles[:99])
self.assertRaises(
AmuseException,
hop.calculate_densities,
expected_message=
"Error when calling 'calculate_densities' of a 'Hop', errorcode is -5, error is 'Too few particles.'"
)
hop.particles.add_particles(particles[99:101])
hop.calculate_densities()
hop.parameters.number_of_neighbors_for_hop = 200
self.assertRaises(
AmuseException,
hop.calculate_densities,
expected_message=
"Error when calling 'calculate_densities' of a 'Hop', errorcode is -5, error is 'Too few particles.'"
)
hop.particles.add_particles(particles[101:])
hop.calculate_densities()
self.assertRaises(
AmuseException,
hop.get_mass,
200,
expected_message=
"Error when calling 'get_mass' of a 'Hop', errorcode is -3, error is 'A particle with the given index was not found.'"
)
hop.stop()
def test_run(N=4,
tend=1. | nbody_system.time,
dt=0.125 | nbody_system.time,
parameters={}):
numpy.random.seed(1233231)
mp = Yaravi()
for key in parameters:
setattr(mp.parameters, key, parameters[key])
print mp.parameters
plum = new_plummer_model(N, do_scale=True)
mp.particles.add_particles(plum)
t1 = time.time()
while mp.model_time < tend - dt / 2:
tnext = mp.model_time + dt
if mp.model_time + dt >= tend - dt / 2:
tnext = tend
mp.evolve_model(tnext)
t2 = time.time()
print t2 - t1, (tend - mp.model_time).number
return mp.particles.copy()
def test19(self):
print("Testing ph4 properties")
particles = new_plummer_model(1000, 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 = ph4()
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 test09(self):
print "Test add_spin particle attribute, to add rigid body rotation"
numpy.random.seed(123456)
particles = new_plummer_model(1000)
kinetic_energy0 = particles.kinetic_energy()
potential_energy0 = particles.potential_energy(G=nbody_system.G)
particles.position += [3, 0, 2] | nbody_system.length
particles.velocity += [1, 10, 100] | nbody_system.speed
particles.add_spin(3.0 | nbody_system.time**-1)
self.assertAlmostRelativeEquals(particles.center_of_mass(), [3, 0, 2] | nbody_system.length, 12)
self.assertAlmostRelativeEquals(particles.potential_energy(G=nbody_system.G), potential_energy0, 12)
self.assertAlmostRelativeEquals(particles.center_of_mass_velocity(), [1, 10, 100] | nbody_system.speed, 12)
r = particles.position - particles.center_of_mass()
v = particles.velocity - particles.center_of_mass_velocity()
spin_direction = (r).cross(v).mean(axis=0)
spin_direction /= spin_direction.length()
R = r - r*spin_direction
omega = ((R).cross(v) / R.lengths_squared().reshape((-1,1))).mean(axis=0).length()
self.assertAlmostEquals(spin_direction, [0, 0, 1.0], 1)
self.assertAlmostEquals(omega, 3.0 | nbody_system.time**-1, 1)
particles.add_spin([1.0, 0, -3.0] | nbody_system.time**-1)
v = particles.velocity - particles.center_of_mass_velocity()
spin_direction = (r).cross(v).mean(axis=0)
spin_direction /= spin_direction.length()
R = r - r*spin_direction
omega = ((R).cross(v) / R.lengths_squared().reshape((-1,1))).mean(axis=0).length()
self.assertAlmostEquals(omega, 1.0 | nbody_system.time**-1, 1)
def __init__(self, name, Mtot=(1e15 | units.MSun), Rvir=(500 | units.kpc)):
self.name = name
self.converter = nbody_system.nbody_to_si(Mtot, Rvir)
self.number_of_dm_particles = 1e2
self.number_of_gas_particles = 1e3
# Set up numerical smoothing fractions
self.dm_smoothing_fraction = 0.001
self.gas_smoothing_fraction = 0.05
self.dm_epsilon = self.dm_smoothing_fraction * Rvir
self.gas_epsilon = self.gas_smoothing_fraction * Rvir
# Setup up gas and dark matter fractions and gas/dm mass
self.gas_fraction = 0.1
self.dm_fraction = 1.0 - self.gas_fraction
self.dm_mass = self.dm_fraction * Mtot
self.gas_mass = self.gas_fraction * Mtot
# Set up dark matter particles
# TODO: probably not use Plummer sphere
self.dm = new_plummer_model(self.number_of_dm_particles,
convert_nbody=self.converter)
self.dm.radius = self.dm_epsilon
self.dm.mass = (1.0 / self.number_of_dm_particles) * self.dm_mass
self.dm.move_to_center()
# Set up virialized gas sphere of N gas particles, Plummer sphere
# TODO: probably not use Plummer sphere
self.gas = new_plummer_gas_model(self.number_of_gas_particles,
convert_nbody=self.converter)
self.gas.h_smooth = self.gas_epsilon
self.gas.move_to_center()
self.gas.mass = (1.0 / self.number_of_gas_particles) * self.gas_mass
print "Created ", str(self)
def test22(self):
particles = new_plummer_model(200)
particles.scale_to_standard()
try:
instance = ph4(mode="gpu")
except:
self.skip("gpu mode is not available")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2
instance.particles.add_particles(particles)
x = numpy.arange(-1,1,0.1) | nbody_system.length
zero = numpy.zeros(len(x)) | nbody_system.length
gpu_potential = instance.get_potential_at_point(zero, x , zero, zero)
instance.stop()
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00000 | nbody_system.length**2
instance.particles.add_particles(particles)
nogpu_potential = instance.get_potential_at_point(zero, x , zero, zero)
self.assertAlmostRelativeEquals(nogpu_potential, gpu_potential, 5)
instance.stop()
def test09(self):
print "Test add_spin particle attribute, to add rigid body rotation"
numpy.random.seed(123456)
particles = new_plummer_model(1000)
kinetic_energy0 = particles.kinetic_energy()
potential_energy0 = particles.potential_energy(G=nbody_system.G)
particles.position += [3, 0, 2] | nbody_system.length
particles.velocity += [1, 10, 100] | nbody_system.speed
particles.add_spin(3.0 | nbody_system.time**-1)
self.assertAlmostRelativeEquals(particles.center_of_mass(), [3, 0, 2] | nbody_system.length, 12)
self.assertAlmostRelativeEquals(particles.potential_energy(G=nbody_system.G), potential_energy0, 12)
self.assertAlmostRelativeEquals(particles.center_of_mass_velocity(), [1, 10, 100] | nbody_system.speed, 12)
r = particles.position - particles.center_of_mass()
v = particles.velocity - particles.center_of_mass_velocity()
spin_direction = (r).cross(v).mean(axis=0)
spin_direction /= spin_direction.length()
R = r - r*spin_direction
omega = ((R).cross(v) / R.lengths_squared().reshape((-1,1))).mean(axis=0).length()
self.assertAlmostEquals(spin_direction, [0, 0, 1.0], 1)
self.assertAlmostEquals(omega, 3.0 | nbody_system.time**-1, 1)
particles.add_spin([1.0, 0, -3.0] | nbody_system.time**-1)
v = particles.velocity - particles.center_of_mass_velocity()
spin_direction = (r).cross(v).mean(axis=0)
spin_direction /= spin_direction.length()
R = r - r*spin_direction
omega = ((R).cross(v) / R.lengths_squared().reshape((-1,1))).mean(axis=0).length()
self.assertAlmostEquals(omega, 1.0 | nbody_system.time**-1, 1)
def test5(self):
print "CalculateFieldForParticles get_potential_at_point, with individual softening"
epsilon = 0.5 | units.parsec
convert = nbody_system.nbody_to_si(1.e5 | units.MSun,
1.0 | units.parsec)
numpy.random.seed(12345)
stars = new_plummer_model(100, convert_nbody=convert)
stars.radius = epsilon * numpy.random.uniform(
low=0.4, high=3.0, size=len(stars))
cluster = ExampleGravityCodeInterface(softening_mode="individual")
cluster.particles.add_particles(stars)
instance = bridge.CalculateFieldForParticles(
particles=stars, softening_mode="individual")
zeros = numpy.zeros(9) | units.parsec
pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec
self.assertAlmostRelativeEqual(
instance.get_potential_at_point(zeros, pos_range, zeros, zeros),
cluster.get_potential_at_point(zeros, pos_range, zeros, zeros))
for a_calculate_field, a_code in zip(
instance.get_gravity_at_point(zeros, pos_range, zeros, zeros),
cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros)):
self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def test5(self):
instance = self.new_instance_of_an_optional_code(HiGPUs)
instance.initialize_code()
instance.parameters.eta6 = 0.01
instance.commit_parameters()
stars = new_plummer_model(100)
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.get_kinetic_energy() + instance.get_potential_energy()
stars.mass *= 0.9
instance.synchronize_model()
e1 = instance.get_kinetic_energy() + instance.get_potential_energy()
instance.cleanup_code()
instance.stop()
delta_e = e1 - e0
self.assertTrue(e1 != e0)
def test3(self):
print "Bridge potential energy with radius as softening length"
convert = nbody_system.nbody_to_si(1.e5 | units.MSun,
1.0 | units.parsec)
epsilon = 0.1 | units.parsec
test_class = ExampleGravityCodeInterface
numpy.random.seed(12345)
stars = new_plummer_model(100, convert_nbody=convert)
stars.radius = epsilon
cluster = test_class()
cluster.parameters.epsilon_squared = epsilon**2
cluster.particles.add_particles(stars)
first_half = stars.select_array(lambda x: (x > 0 | units.m), ['x'])
second_half = stars - first_half
cluster1 = system_from_particles(test_class, dict(), first_half,
epsilon)
cluster2 = system_from_particles(test_class, dict(), second_half,
epsilon)
bridgesys = bridge.Bridge()
bridgesys.add_system(cluster1, (cluster2, ), radius_is_eps=True)
bridgesys.add_system(cluster2, (cluster1, ))
self.assertAlmostRelativeEqual(cluster.potential_energy,
bridgesys.potential_energy)
self.assertAlmostRelativeEqual(cluster.kinetic_energy,
bridgesys.kinetic_energy)
def test10(self):
instance = PhiGRAPE(**default_test_options)
instance.initialize_code()
instance.parameters.set_defaults()
stars = new_plummer_model(100)
stars.radius = 0 | nbody_system.length
instance.particles.add_particles(stars)
channel = stars.new_channel_to(instance.particles)
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.kinetic_energy + instance.potential_energy
stars.mass *= 0.9
channel.copy()
instance.synchronize_model()
e1 = instance.kinetic_energy + instance.potential_energy
delta_e = e1 - e0
self.assertTrue(e1 != e0)
instance.stop()
def test3(self):
print "CalculateFieldForParticles get_potential_at_point, no softening"
epsilon = 0 | units.m
convert = nbody_system.nbody_to_si(1.e5 | units.MSun,
1.0 | units.parsec)
numpy.random.seed(12345)
stars = new_plummer_model(100, convert_nbody=convert)
cluster = ExampleGravityCodeInterface()
cluster.parameters.epsilon_squared = epsilon**2
cluster.particles.add_particles(stars)
instance = bridge.CalculateFieldForParticles(particles=stars)
instance.smoothing_length_squared = epsilon**2
zeros = numpy.zeros(9) | units.parsec
pos_range = numpy.linspace(-1.0, 1.0, 9) | units.parsec
self.assertAlmostRelativeEqual(
instance.get_potential_at_point(zeros, pos_range, zeros, zeros),
cluster.get_potential_at_point(zeros, pos_range, zeros, zeros))
for a_calculate_field, a_code in zip(
instance.get_gravity_at_point(zeros, pos_range, zeros, zeros),
cluster.get_gravity_at_point(zeros, pos_range, zeros, zeros)):
self.assertAlmostRelativeEqual(a_calculate_field, a_code, 12)
def simulate_small_cluster(number_of_stars=1000,
end_time=40 | nbody_system.time,
number_of_workers=1):
particles = new_plummer_model(number_of_stars)
particles.scale_to_standard()
gravity = Hermite(number_of_workers=number_of_workers)
gravity.parameters.epsilon_squared = 0.15 | nbody_system.length**2
gravity.particles.add_particles(particles)
from_gravity_to_model = gravity.particles.new_channel_to(particles)
time = 0.0 * end_time
total_energy_at_t0 = gravity.kinetic_energy + gravity.potential_energy
positions_at_different_times = []
positions_at_different_times.append(particles.position)
times = []
times.append(time)
print("evolving the model until t = " + str(end_time))
while time < end_time:
time += end_time / 3.0
gravity.evolve_model(time)
from_gravity_to_model.copy()
positions_at_different_times.append(particles.position)
times.append(time)
print_log(time, gravity, particles, total_energy_at_t0)
gravity.stop()
return times, positions_at_different_times
def test15(self):
particles = plummer.new_plummer_model(512)
expected_positions = None
for mode in ["cpu", "openmp", "opencl"]:
try:
instance = Huayno(mode=mode,
number_of_workers=1) #, debugger="xterm")
except:
print("Running huayno with mode=", mode, " was unsuccessful.")
continue
else:
print("Running huayno with mode=", mode, "... ")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
instance.synchronize_model()
if expected_positions is None:
expected_positions = instance.particles.position
else:
self.assertAlmostRelativeEquals(expected_positions,
instance.particles.position, 8)
instance.stop()
def test19(self):
print "Testing ph4 properties"
particles = new_plummer_model(1000, 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 = ph4()
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 test5(self):
instance = self.new_instance_of_an_optional_code(HiGPUs)
instance.initialize_code()
instance.parameters.eta6 = 0.01
instance.commit_parameters()
stars = new_plummer_model(100)
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.get_kinetic_energy() + instance.get_potential_energy()
stars.mass *= 0.9
instance.synchronize_model()
e1 = instance.get_kinetic_energy() + instance.get_potential_energy()
instance.cleanup_code()
instance.stop()
delta_e = e1 - e0
self.assertTrue(e1 != e0)
def test10(self):
instance = ph4()
instance.initialize_code()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length ** 2
instance.parameters.timestep_parameter = 0.01
stars = new_plummer_model(100)
instance.particles.add_particles(stars)
channel = stars.new_channel_to(instance.particles)
instance.evolve_model(0.001 | nbody_system.time)
e0 = instance.kinetic_energy + instance.potential_energy
stars.mass *= 0.9
channel.copy()
instance.synchronize_model()
e1 = instance.kinetic_energy + instance.potential_energy
instance.cleanup_code()
instance.stop()
delta_e = e1 - e0
self.assertTrue(e1 != e0)
def test4(self):
stars = new_plummer_model(2, do_scale = True)
self.assertAlmostEqual(stars.kinetic_energy(), 0.25 | nbody_system.energy)
self.assertAlmostEqual(stars.potential_energy(G=nbody_system.G), -0.50 | nbody_system.energy)
self.assertAlmostEqual(stars.center_of_mass(), [0,0,0] | nbody_system.length)
self.assertAlmostEqual(stars.center_of_mass_velocity(), [0,0,0] | nbody_system.speed)
self.assertAlmostEqual(stars.mass.sum(), 1.00 | nbody_system.mass)
self.assertAlmostEqual(stars.virial_radius(), 1.00 | nbody_system.length)
def create_stars(number_of_stars, size):
masses = new_salpeter_mass_distribution(number_of_stars, mass_min = 2|units.MSun)
converter = nbody_system.nbody_to_si(masses.sum(), size)
stars = new_plummer_model(number_of_stars, convert_nbody=converter)
stars.mass = masses
stars.zams_mass = masses
return stars, converter
def test28(self):
particles = plummer.new_plummer_model(31)
instance = Huayno()
instance.particles.add_particles(particles)
self.assertAlmostEqual(particles.total_mass(),instance.total_mass)
self.assertAlmostEqual(particles.center_of_mass(),instance.center_of_mass_position)
self.assertAlmostEqual(particles.center_of_mass_velocity(),instance.center_of_mass_velocity)
def test23(self):
print "testing removing and adding particles repeatedly"
N=1100
p1=plummer.new_plummer_model(N)
p2=plummer.new_plummer_model(N)
h1=Huayno()
h1.particles.add_particles(p1[:N/2])
h1.particles.add_particles(p2[-N/2:])
h2=Huayno()
h2.particles.add_particles(p1)
h2.particles.remove_particles(p1[N/2:])
h2.particles.add_particles(p2)
h2.particles.remove_particles(p2[:-N/2])
self.assertEqual(len(h1.particles),len(h2.particles))
self.assertAlmostEqual(h1.kinetic_energy,h2.kinetic_energy,15)
self.assertAlmostEqual(h1.potential_energy,h2.potential_energy,15)
def test16(self):
print "Testing ph4 states"
stars = new_plummer_model(100)
black_hole = datamodel.Particle()
black_hole.mass = 1.0 | nbody_system.mass
black_hole.radius = 0.0 | nbody_system.length
black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length
black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
print "First do everything manually:"
instance = ph4()
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.timestep_parameter = 0.01
instance.commit_parameters()
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
instance.recommit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
instance.synchronize_model()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEquals(instance.get_name_of_current_state(), 'END')
instance.stop()
print "initialize_code(), commit_parameters(), (re)commit_particles(), " \
"synchronize_model(), and cleanup_code() should be called " \
"automatically before editing parameters, new_particle(), get_xx(), and stop():"
instance = ph4()
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
instance.parameters.timestep_parameter = 0.01
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def integrate_system(N, t_end, seed=None):
gravity = ph4()
gravity.initialize_code()
gravity.parameters.set_defaults()
if seed is not None: numpy.random.seed(seed)
stars = new_plummer_model(N)
stars.mass = 1./N | nbody_system.mass
stars.scale_to_standard(smoothing_length_squared
= gravity.parameters.epsilon_squared)
id = numpy.arange(N)
stars.id = id+1
# Set dynamical radii for encounters.
stars.radius = 0.5*stars.mass.number | nbody_system.length
gravity.particles.add_particles(stars)
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
init_smalln()
kep = Kepler(unit_converter=None)
kep.initialize_code()
multiples_code = multiples.Multiples(gravity, new_smalln, kep)
multiples_code.neighbor_perturbation_limit = 0.05
multiples_code.global_debug = 1
# global_debug = 0: no output from multiples
# 1: minimal output
# 2: debugging output
# 3: even more output
print ''
print 'multiples_code.neighbor_veto =', \
multiples_code.neighbor_veto
print 'multiples_code.neighbor_perturbation_limit =', \
multiples_code.neighbor_perturbation_limit
print 'multiples_code.retain_binary_apocenter =', \
multiples_code.retain_binary_apocenter
print 'multiples_code.wide_perturbation_limit =', \
multiples_code.wide_perturbation_limit
# Advance the system.
E0 = print_diagnostics(multiples_code)
multiples_code.evolve_model(t_end)
print_diagnostics(multiples_code, E0)
gravity.stop()
kep.stop()
stop_smalln()
def test7(self):
print "Testing Pikachu states"
stars = new_plummer_model(100)
black_hole = Particle()
black_hole.mass = 1.0 | nbody_system.mass
black_hole.radius = 0.0 | nbody_system.length
black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length
black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed
print "First do everything manually:"
instance = self.new_instance_of_an_optional_code(Pikachu, **default_options)
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.initialize_code()
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
#~ instance.parameters.rcut_out_star_star = 1.0 | nbody_system.length
instance.parameters.timestep = 0.001 | nbody_system.time
instance.commit_parameters()
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
instance.recommit_particles()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
instance.synchronize_model()
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.cleanup_code()
self.assertEquals(instance.get_name_of_current_state(), 'END')
instance.stop()
print "initialize_code(), commit_parameters(), (re)commit_particles(), " \
"synchronize_model(), and cleanup_code() should be called " \
"automatically before editing parameters, new_particle(), get_xx(), and stop():"
instance = self.new_instance_of_an_optional_code(Pikachu, **default_options)
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.timestep = 0.001 | nbody_system.time
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEquals(instance.get_name_of_current_state(), 'EDIT')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.particles.remove_particle(stars[0])
instance.particles.add_particle(black_hole)
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.evolve_model(0.001 | nbody_system.time)
self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED')
mass = instance.particles[0].mass
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def test3(self):
print "Testing Bonsai, N-body units"
instance = self.new_instance_of_an_optional_code(Bonsai, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500)
instance.particles.add_particles(plummer)
self.assertAlmostEquals(instance.particles.mass, 0.002 | nbody_system.mass)
instance.evolve_model(1.0 | nbody_system.time)
self.assertAlmostEquals(instance.model_time, 1.0 | nbody_system.time)
instance.stop()
def test4(self):
print "Testing Bonsai, SI units"
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun, 1.0 | units.parsec)
instance = self.new_instance_of_an_optional_code(Bonsai, convert_nbody, **default_options)
instance.initialize_code()
plummer = new_plummer_model(500, convert_nbody = convert_nbody)
instance.particles.add_particles(plummer)
instance.commit_particles()
instance.evolve_model(1 | nbody_system.time)
instance.stop()
