def test4(self):
print "Test new_particle_from_cluster_core - SI units"
numpy.random.seed(123)
converter = nbody_system.nbody_to_si(1000.0|units.MSun, 1.0 | units.parsec)
plummer = new_plummer_sphere(10000, convert_nbody=converter)
result = plummer.new_particle_from_cluster_core(unit_converter=converter, density_weighting_power=1, reuse_hop=True)
self.assertTrue(isinstance(result, Particle))
# Casertano & Hut (1985, ApJ, 298, 80): density weighted core radius = 0.6791 * r_plummer
plummer_radius = 3 * constants.pi / 16.0 | units.parsec
self.assertAlmostRelativeEqual(result.radius, 0.6791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [0.0, 0.0, 0.0] | units.parsec, 1)
self.assertAlmostEqual(result.velocity, [0.0, 0.0, 0.0] | units.km / units.s, 1)
self.assertAlmostEqual(result.density, 3.55015420914e3 | units.MSun * units.parsec**-3)
plummer.vx += 42 | units.km / units.s
plummer.vy += (1 - plummer.y / abs(plummer.y).amax()) * (13|units.km / units.s)
plummer.position *= 0.1
plummer.position += [1.0, 2.0, 3.0] | units.parsec
result = plummer.new_particle_from_cluster_core(unit_converter=converter, density_weighting_power=1, reuse_hop=False)
self.assertTrue(isinstance(result, Particle))
self.assertAlmostRelativeEqual(result.radius, 0.06791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [1.0, 2.0, 3.0] | units.parsec, 1)
self.assertAlmostEqual(result.velocity, [42.0, 13.0, 0.0] | units.km / units.s, 1)
self.assertAlmostRelativeEqual(result.density, 3.55015420914e6 | units.MSun * units.parsec**-3, 4)
def test10(self):
particles = Particles(2)
particles.position = [[1, 0, 0], [2,0,0]] | units.m
particles.velocity = [[3, 0, 0], [4,0,0]] | units.m / units.s
particles.mass = 1 | units.kg
self.assertEquals(particles.total_mass(), 2 | units.kg)
self.assertEquals(particles.total_momentum(), [7, 0, 0] | units.kg * units.m / units.s)
self.assertEquals(particles.total_momentum(), particles.total_mass() * particles.center_of_mass_velocity())
self.assertEquals(particles.total_radius(), 0.5 | units.m)
convert_nbody = nbody_system.nbody_to_si(1000 | units.kg, 1e-6 | units.m)
numpy.random.seed(123)
field = new_plummer_sphere(10000, convert_nbody) # small clump of particles, can be regarded as point mass
self.assertAlmostRelativeEquals(particles.potential_energy_in_field(field), -constants.G * (1500 | units.kg**2 / units.m), 5)
self.assertAlmostEquals(particles.potential_energy_in_field(field), -1.001142 | 1e-7 * units.kg * units.m**2 / units.s**2, 5)
field.position *= ((5 | units.m) / field.position.lengths()).reshape((-1, 1)) # spherical shell around particles
potential_energy = particles.potential_energy_in_field(field)
particles.position += [0, 1, 2] | units.m # as long as particles remain inside the shell, the potential doesn't change
self.assertAlmostEquals(particles.potential_energy_in_field(field), potential_energy, 5)
particles.mass = [1, 2] | units.kg
self.assertAlmostRelativeEquals(particles.potential(), -constants.G * ([2, 1] | units.kg / units.m))
self.assertAlmostRelativeEquals(particles.potential()[0], particles[0].potential())
self.assertAlmostRelativeEquals(particles.potential()[1], particles[1].potential())
def test3(self):
print "Test new_particle_from_cluster_core - nbody units"
numpy.random.seed(123)
plummer = new_plummer_sphere(10000)
result = plummer.new_particle_from_cluster_core(density_weighting_power=1, reuse_hop=True)
self.assertTrue(isinstance(result, Particle))
# Casertano & Hut (1985, ApJ, 298, 80): density weighted core radius = 0.6791 * r_plummer
plummer_radius = 3 * constants.pi / 16.0 | nbody_system.length
self.assertAlmostRelativeEqual(result.radius, 0.6791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [0.0, 0.0, 0.0] | nbody_system.length, 1)
self.assertAlmostEqual(result.velocity, [0.0, 0.0, 0.0] | nbody_system.speed, 1)
self.assertAlmostEqual(result.density, 3.55015420914 | nbody_system.density)
plummer.vx += 42 | nbody_system.speed
plummer.vy += (1 - plummer.y / abs(plummer.y).amax()) * (13|nbody_system.speed)
plummer.position *= 0.1
plummer.position += [1.0, 2.0, 3.0] | nbody_system.length
result = plummer.new_particle_from_cluster_core(density_weighting_power=1, reuse_hop=False)
self.assertTrue(isinstance(result, Particle))
self.assertAlmostRelativeEqual(result.radius, 0.06791 * plummer_radius, 2)
self.assertAlmostEqual(result.position, [1.0, 2.0, 3.0] | nbody_system.length, 1)
self.assertAlmostEqual(result.velocity, [42.0, 13.0, 0.0] | nbody_system.speed, 1)
self.assertAlmostRelativeEqual(result.density, 3.55015420914e3 | nbody_system.density, 4)
def __init__(self,
num_stars,
xoffset,
yoffset,
zoffset,
repopulate_every_run=True):
self.num_stars = num_stars
self.xoffset = xoffset
self.yoffset = yoffset
self.zoffset = zoffset
self.repopulate_every_run = repopulate_every_run
if repopulate_every_run is False:
# create nbody_converter thing?
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun,
1 | units.parsec)
# instantiate plummer sphere
self.initial_plummer = new_plummer_sphere(self.num_stars,
convert_nbody)
self.initial_plummer.x += self.xoffset | units.lightyear
self.initial_plummer.y += self.yoffset | units.lightyear
self.initial_plummer.z += self.zoffset | units.lightyear
# provide mass distribution for stars
self.initial_plummer.mass = new_salpeter_mass_distribution(
self.num_stars)
self.plummer = None
def test8(self):
print "Test mass_segregation_ratio"
numpy.random.seed(123)
random.seed(456)
number_of_particles = 10000
particles = new_plummer_sphere(number_of_particles)
particles.r_squared = particles.position.lengths_squared()
sorted = particles.sorted_by_attribute("r_squared")
sorted.mass = numpy.random.uniform(
1.0, 2.0, number_of_particles) | nbody_system.mass
MSR = sorted.mass_segregation_ratio(number_of_particles=10,
number_of_random_sets=10)
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(MSR, 0.7160, 3)
else:
self.assertAlmostEquals(MSR, 0.8877, 3)
random.seed(456)
result = sorted.mass_segregation_ratio(number_of_particles=10,
number_of_random_sets=10,
also_compute_uncertainty=True)
self.assertTrue(
isinstance(result,
particle_attributes.MassSegregationRatioResults))
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(result.mass_segregation_ratio, 0.7160, 3)
self.assertAlmostEquals(result.uncertainty, 0.2321, 3)
else:
self.assertAlmostEquals(result.mass_segregation_ratio, 0.8877, 3)
self.assertAlmostEquals(result.uncertainty, 0.2482, 3)
MSR, sigma = sorted.mass_segregation_ratio(
number_of_particles=10,
number_of_random_sets=50,
also_compute_uncertainty=True)
self.assertTrue(MSR - sigma < 1.0 < MSR + sigma)
sorted.mass = numpy.linspace(1.0, 2.0,
number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_ratio(
number_of_particles=10,
number_of_random_sets=20,
also_compute_uncertainty=True)
self.assertTrue(MSR < 0.1)
self.assertTrue(sigma < MSR)
sorted.mass = numpy.linspace(2.0, 1.0,
number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_ratio(
number_of_particles=10,
number_of_random_sets=20,
also_compute_uncertainty=True)
self.assertTrue(MSR > 10.0)
self.assertTrue(sigma < MSR)
def create_cluster_with_IMF(N=100, radius=3 | units.parsec):
'''
Creation of a cluster following a Kroupa IMF
'''
masses = new_broken_power_law_mass_distribution(
N, mass_boundaries=[0.08, 0.5, 100] | units.MSun, alphas=[-1.3, -2.3])
convert_nbody = nbody_system.nbody_to_si(masses.sum(), radius)
cluster = new_plummer_sphere(N, convert_nbody)
cluster.mass = masses
cluster.move_to_center()
cluster.scale_to_standard(convert_nbody)
return cluster
def create_cluster_with_IMF(N=100, radius=3 |units.parsec):
'''
Creation of a cluster following a Kroupa IMF
'''
masses=new_broken_power_law_mass_distribution(N,
mass_boundaries= [0.08, 0.5, 100] |units.MSun,
alphas= [-1.3,-2.3] )
convert_nbody=nbody_system.nbody_to_si(masses.sum(),radius)
cluster=new_plummer_sphere(N, convert_nbody)
cluster.mass= masses
cluster.move_to_center()
cluster.scale_to_standard(convert_nbody)
return cluster
def test6(self):
print "Test all particle attributes using Hop - each different function creates its own instance of Hop"
numpy.random.seed(123)
nbody_plummer = new_plummer_sphere(100)
nbody_plummer.mass = new_salpeter_mass_distribution_nbody(100)
# Each different function creates its own instance of Hop
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=True)
result = nbody_plummer.bound_subset(G=nbody_system.G, reuse_hop=True)
result = nbody_plummer.mass_segregation_Gini_coefficient(reuse_hop=True)
result = nbody_plummer.LagrangianRadii(reuse_hop=True)
result = nbody_plummer.densitycentre_coreradius_coredens(reuse_hop=True)
converter = nbody_system.nbody_to_si(1.0|units.MSun, 1.0 | units.parsec)
si_plummer = ParticlesWithUnitsConverted(nbody_plummer, converter.as_converter_from_si_to_nbody())
functions_using_hop = [
si_plummer.new_particle_from_cluster_core,
si_plummer.bound_subset,
si_plummer.mass_segregation_Gini_coefficient,
si_plummer.LagrangianRadii,
si_plummer.densitycentre_coreradius_coredens
]
# Each fails since the Hop instance it tries to reuse has a different unit_converter
for function_using_hop in functions_using_hop:
self.assertRaises(ConvertArgumentsException, function_using_hop, unit_converter=converter,
expected_message="error while converting parameter 'mass', error: Cannot express kg in mass, the units do not have the same bases")
# Close all Hop instances:
nbody_results = []
nbody_results.append(nbody_plummer.new_particle_from_cluster_core(reuse_hop=False))
nbody_results.append(nbody_plummer.bound_subset(G=nbody_system.G, reuse_hop=False))
nbody_results.append(nbody_plummer.mass_segregation_Gini_coefficient(reuse_hop=False))
nbody_results.append(nbody_plummer.LagrangianRadii(reuse_hop=False))
nbody_results.append(nbody_plummer.densitycentre_coreradius_coredens(reuse_hop=False))
# Now it works, because the Hop instances were closed, and new ones will be instantiated
si_results = []
for function_using_hop in functions_using_hop:
si_results.append(function_using_hop(unit_converter=converter))
convert = converter.as_converter_from_si_to_nbody()
self.assertAlmostRelativeEqual(si_results[0].position,
ParticlesWithUnitsConverted(nbody_results[0].as_set(), convert)[0].position)
self.assertAlmostRelativeEqual(si_results[1].position,
ParticlesWithUnitsConverted(nbody_results[1], convert).position)
self.assertAlmostRelativeEqual(si_results[2], nbody_results[2], places=10)
self.assertAlmostRelativeEqual(si_results[3][0], convert.from_target_to_source(nbody_results[3][0]), places=10)
for in_si, in_nbody in zip(si_results[4], nbody_results[4]):
self.assertAlmostRelativeEqual(in_si, convert.from_target_to_source(in_nbody), places=10)
def test5(self):
print "Test new_particle_from_cluster_core - reuse_hop or not"
converter = nbody_system.nbody_to_si(1.0 | units.MSun,
1.0 | units.parsec)
plummer = new_plummer_sphere(100, convert_nbody=converter)
result = plummer.new_particle_from_cluster_core(
unit_converter=converter, reuse_hop=True)
# Hop wasn't stopped, will use same Hop instance:
result = plummer.new_particle_from_cluster_core(
unit_converter=converter, reuse_hop=True)
nbody_plummer = new_plummer_sphere(100)
# Hop wasn't stopped, unit_converters don't match:
self.assertRaises(
AttributeError,
nbody_plummer.new_particle_from_cluster_core,
expected_message=
"Cannot combine units from different systems: m and length")
result = plummer.new_particle_from_cluster_core(
unit_converter=converter, reuse_hop=False)
# Hop was stopped, new instance will be made with supplied unit_converter (None in this case):
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=True)
self.assertRaises(
ConvertArgumentsException,
plummer.new_particle_from_cluster_core,
unit_converter=converter, #,
expected_message=
"error while converting parameter 'mass', error: Cannot express kg in mass, the units do not have the same bases"
)
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=False)
result = plummer.new_particle_from_cluster_core(
unit_converter=converter, reuse_hop=False)
def test5(self):
print "Test new_particle_from_cluster_core - reuse_hop or not"
converter = nbody_system.nbody_to_si(1.0|units.MSun, 1.0 | units.parsec)
plummer = new_plummer_sphere(100, convert_nbody=converter)
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=True)
# Hop wasn't stopped, will use same Hop instance:
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=True)
nbody_plummer = new_plummer_sphere(100)
# Hop wasn't stopped, unit_converters don't match:
self.assertRaises(AttributeError, nbody_plummer.new_particle_from_cluster_core,
expected_message="Cannot combine units from different systems: m and length")
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=False)
# Hop was stopped, new instance will be made with supplied unit_converter (None in this case):
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=True)
self.assertRaises(ConvertArgumentsException, plummer.new_particle_from_cluster_core, unit_converter=converter,#,
expected_message="error while converting parameter 'mass', error: Cannot express kg in mass, the units do not have the same bases")
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=False)
result = plummer.new_particle_from_cluster_core(unit_converter=converter, reuse_hop=False)
def test15(self):
scale_R = 1.0 | units.parsec
scale_M = 1000.0 | units.MSun
converter = nbody_system.nbody_to_si(scale_M, scale_R)
for n in range(3162, 3165, 1):
stars = new_plummer_sphere(
n,
convert_nbody=converter,
)
stars.mass = (numpy.arange(1, n + 1) / (1. * n)) | units.MSun
potential = stars.potential()
for i, x in enumerate(stars):
self.assertAlmostRelativeEqual(potential[i], x.potential())
def test16(self):
scale_R = 1.0 | units.parsec
scale_M = 1000.0 | units.MSun
converter = nbody_system.nbody_to_si(scale_M, scale_R)
for n in range(0, 50):
stars = new_plummer_sphere(
50,
convert_nbody=converter,
)
stars.mass = numpy.arange(1, 51) | units.MSun
potential = stars.potential(block_size=n)
for i, x in enumerate(stars):
self.assertAlmostRelativeEqual(potential[i], x.potential())
def test14(self):
print "Test mass_segregation_from_nearest_neighbour"
numpy.random.seed(123)
random.seed(4567)
number_of_particles = 1000
particles = new_plummer_sphere(number_of_particles)
particles.r_squared = particles.position.lengths_squared()
sorted = particles.sorted_by_attribute("r_squared")
sorted.mass = numpy.random.uniform(
1.0, 2.0, number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_from_nearest_neighbour(
number_of_particles=10, also_compute_uncertainty=True)
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(MSR, 1.72632, 3)
self.assertAlmostEquals(sigma, 0.4127, 3)
else:
self.assertAlmostEquals(MSR, 1.7355, 3)
self.assertAlmostEquals(sigma, 0.3969, 3)
random.seed(456)
MSR_of_nonsegregated_systems = []
for i in range(10):
sorted.mass = numpy.random.uniform(
1.0, 2.0, number_of_particles) | nbody_system.mass
MSR = sorted.mass_segregation_from_nearest_neighbour(
number_of_particles=10, number_of_random_sets=50)
MSR_of_nonsegregated_systems.append(MSR)
self.assertAlmostEquals(
(MSR_of_nonsegregated_systems | units.none).mean(), 1.0, 1)
self.assertAlmostEquals(
(MSR_of_nonsegregated_systems | units.none).std(), 0.3, 1)
sorted.mass = numpy.linspace(2.0, 1.0,
number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_from_nearest_neighbour(
number_of_particles=10,
number_of_random_sets=20,
also_compute_uncertainty=True)
self.assertTrue(MSR > 5.0)
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(sigma, 0.3, 1)
else:
self.assertAlmostEquals(sigma, 0.4, 1)
def populate(self):
if self.repopulate_every_run:
# create nbody_converter thing?
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun,
1 | units.parsec)
# instantiate plummer sphere
self.plummer = new_plummer_sphere(self.num_stars, convert_nbody)
self.plummer.x += self.xoffset | units.lightyear
self.plummer.y += self.yoffset | units.lightyear
self.plummer.z += self.zoffset | units.lightyear
# provide mass distribution for stars
self.plummer.mass = new_salpeter_mass_distribution(self.num_stars)
else:
self.plummer = self.initial_plummer
def plummer_with_planets_initial_conditions(n=128,
frac_planets=0.5,
m_star=None,
m_planet=10e-10,
a_planet=0.001,
e_planet=0.5,
v=False):
stars = new_plummer_sphere(n)
# print average distance between stars
if v:
avg_star_dist = 0.0
for stari in stars:
for starj in stars:
if stari != starj:
dvec = (starj.position - stari.position).value_in(
nbu.length)
d = math.sqrt(dvec[0]**2 + dvec[1]**2 + dvec[2]**2)
avg_star_dist = avg_star_dist + d / len(stars)
print "Average distance between stars: %f, semi-major axis: %f" % (
avg_star_dist, a_planet)
# normalize "integration work per planetary system", attempt #2
if not (m_star is None):
for star in stars:
star.mass = m_star | nbu.mass
planets = datamodel.Stars(int(frac_planets * n))
for (star, planet) in zip(stars, planets):
adj = two_body_initial_conditions(star.mass.value_in(nbu.mass),
m_planet, a_planet, e_planet)
planet.position = star.position + adj[1].position
star.position = star.position + adj[0].position
planet.velocity = star.velocity + adj[1].velocity
star.velocity = star.velocity + adj[0].velocity
# hack, remove
#star.mass = (1 / float(n)) | nbu.mass
planet.mass = m_planet | nbu.mass
planet.radius = 0. | nbu.length
sys_orbital_period = two_body_orbital_period(
star.mass.value_in(nbu.mass), planet.mass.value_in(nbu.mass),
a_planet, e_planet)
if v: print "Orbital period: %f" % (sys_orbital_period, )
stars.add_particles(planets)
if v:
print "All particles (first n/2: stars, second n/2: planets)"
print stars
return stars
def test10(self):
particles = Particles(2)
particles.position = [[1, 0, 0], [2, 0, 0]] | units.m
particles.velocity = [[3, 0, 0], [4, 0, 0]] | units.m / units.s
particles.mass = 1 | units.kg
self.assertEquals(particles.total_mass(), 2 | units.kg)
self.assertEquals(particles.total_momentum(),
[7, 0, 0] | units.kg * units.m / units.s)
self.assertEquals(
particles.total_momentum(),
particles.total_mass() * particles.center_of_mass_velocity())
self.assertEquals(particles.total_radius(), 0.5 | units.m)
convert_nbody = nbody_system.nbody_to_si(1000 | units.kg,
1e-6 | units.m)
numpy.random.seed(123)
field = new_plummer_sphere(
10000, convert_nbody
) # small clump of particles, can be regarded as point mass
self.assertAlmostRelativeEquals(
particles.potential_energy_in_field(field),
-constants.G * (1500 | units.kg**2 / units.m), 5)
self.assertAlmostEquals(
particles.potential_energy_in_field(field),
-1.001142 | 1e-7 * units.kg * units.m**2 / units.s**2, 5)
field.position *= ((5 | units.m) / field.position.lengths()).reshape(
(-1, 1)) # spherical shell around particles
potential_energy = particles.potential_energy_in_field(field)
particles.position += [
0, 1, 2
] | units.m # as long as particles remain inside the shell, the potential doesn't change
self.assertAlmostEquals(particles.potential_energy_in_field(field),
potential_energy, 5)
particles.mass = [1, 2] | units.kg
self.assertAlmostRelativeEquals(
particles.potential(),
-constants.G * ([2, 1] | units.kg / units.m))
self.assertAlmostRelativeEquals(particles.potential()[0],
particles[0].potential())
self.assertAlmostRelativeEquals(particles.potential()[1],
particles[1].potential())
def test4(self):
print "Test new_particle_from_cluster_core - SI units"
numpy.random.seed(123)
converter = nbody_system.nbody_to_si(1000.0 | units.MSun,
1.0 | units.parsec)
plummer = new_plummer_sphere(10000, convert_nbody=converter)
result = plummer.new_particle_from_cluster_core(
unit_converter=converter,
density_weighting_power=1,
reuse_hop=True)
self.assertTrue(isinstance(result, Particle))
# Casertano & Hut (1985, ApJ, 298, 80): density weighted core radius = 0.6791 * r_plummer
plummer_radius = 3 * constants.pi / 16.0 | units.parsec
self.assertAlmostRelativeEqual(result.radius, 0.6791 * plummer_radius,
2)
self.assertAlmostEqual(result.position, [0.0, 0.0, 0.0] | units.parsec,
1)
self.assertAlmostEqual(result.velocity,
[0.0, 0.0, 0.0] | units.km / units.s, 1)
self.assertAlmostEqual(result.density,
3.55015420914e3 | units.MSun * units.parsec**-3)
plummer.vx += 42 | units.km / units.s
plummer.vy += (1 - plummer.y / abs(plummer.y).amax()) * (
13 | units.km / units.s)
plummer.position *= 0.1
plummer.position += [1.0, 2.0, 3.0] | units.parsec
result = plummer.new_particle_from_cluster_core(
unit_converter=converter,
density_weighting_power=1,
reuse_hop=False)
self.assertTrue(isinstance(result, Particle))
self.assertAlmostRelativeEqual(result.radius, 0.06791 * plummer_radius,
2)
self.assertAlmostEqual(result.position, [1.0, 2.0, 3.0] | units.parsec,
1)
self.assertAlmostEqual(result.velocity,
[42.0, 13.0, 0.0] | units.km / units.s, 1)
self.assertAlmostRelativeEqual(
result.density, 3.55015420914e6 | units.MSun * units.parsec**-3, 4)
def test8(self):
print "Test mass_segregation_ratio"
numpy.random.seed(123)
random.seed(456)
number_of_particles = 10000
particles = new_plummer_sphere(number_of_particles)
particles.r_squared = particles.position.lengths_squared()
sorted = particles.sorted_by_attribute("r_squared")
sorted.mass = numpy.random.uniform(1.0, 2.0, number_of_particles) | nbody_system.mass
MSR = sorted.mass_segregation_ratio(number_of_particles=10, number_of_random_sets=10)
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(MSR, 0.7160, 3)
else:
self.assertAlmostEquals(MSR, 0.8877, 3)
random.seed(456)
result = sorted.mass_segregation_ratio(number_of_particles=10, number_of_random_sets=10, also_compute_uncertainty=True)
self.assertTrue(isinstance(result, particle_attributes.MassSegregationRatioResults))
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(result.mass_segregation_ratio, 0.7160, 3)
self.assertAlmostEquals(result.uncertainty, 0.2321, 3)
else:
self.assertAlmostEquals(result.mass_segregation_ratio, 0.8877, 3)
self.assertAlmostEquals(result.uncertainty, 0.2482, 3)
MSR, sigma = sorted.mass_segregation_ratio(number_of_particles=10, number_of_random_sets=50, also_compute_uncertainty=True)
self.assertTrue(MSR - sigma < 1.0 < MSR + sigma)
sorted.mass = numpy.linspace(1.0, 2.0, number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_ratio(number_of_particles=10, number_of_random_sets=20,
also_compute_uncertainty=True)
self.assertTrue(MSR < 0.1)
self.assertTrue(sigma < MSR)
sorted.mass = numpy.linspace(2.0, 1.0, number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_ratio(number_of_particles=10, number_of_random_sets=20,
also_compute_uncertainty=True)
self.assertTrue(MSR > 10.0)
self.assertTrue(sigma < MSR)
def test3(self):
print "Test new_particle_from_cluster_core - nbody units"
numpy.random.seed(123)
plummer = new_plummer_sphere(10000)
result = plummer.new_particle_from_cluster_core(
density_weighting_power=1, reuse_hop=True)
self.assertTrue(isinstance(result, Particle))
# Casertano & Hut (1985, ApJ, 298, 80): density weighted core radius = 0.6791 * r_plummer
plummer_radius = 3 * constants.pi / 16.0 | nbody_system.length
self.assertAlmostRelativeEqual(result.radius, 0.6791 * plummer_radius,
2)
self.assertAlmostEqual(result.position,
[0.0, 0.0, 0.0] | nbody_system.length, 1)
self.assertAlmostEqual(result.velocity,
[0.0, 0.0, 0.0] | nbody_system.speed, 1)
self.assertAlmostEqual(result.density,
3.55015420914 | nbody_system.density)
plummer.vx += 42 | nbody_system.speed
plummer.vy += (1 - plummer.y / abs(plummer.y).amax()) * (
13 | nbody_system.speed)
plummer.position *= 0.1
plummer.position += [1.0, 2.0, 3.0] | nbody_system.length
result = plummer.new_particle_from_cluster_core(
density_weighting_power=1, reuse_hop=False)
self.assertTrue(isinstance(result, Particle))
self.assertAlmostRelativeEqual(result.radius, 0.06791 * plummer_radius,
2)
self.assertAlmostEqual(result.position,
[1.0, 2.0, 3.0] | nbody_system.length, 1)
self.assertAlmostEqual(result.velocity,
[42.0, 13.0, 0.0] | nbody_system.speed, 1)
self.assertAlmostRelativeEqual(result.density,
3.55015420914e3 | nbody_system.density,
4)
def test14(self):
print "Test mass_segregation_from_nearest_neighbour"
numpy.random.seed(123)
random.seed(4567)
number_of_particles = 1000
particles = new_plummer_sphere(number_of_particles)
particles.r_squared = particles.position.lengths_squared()
sorted = particles.sorted_by_attribute("r_squared")
sorted.mass = numpy.random.uniform(1.0, 2.0, number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_from_nearest_neighbour(number_of_particles=10, also_compute_uncertainty=True)
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(MSR, 1.72632, 3)
self.assertAlmostEquals(sigma, 0.4127, 3)
else:
self.assertAlmostEquals(MSR, 1.7355, 3)
self.assertAlmostEquals(sigma, 0.3969, 3)
random.seed(456)
MSR_of_nonsegregated_systems = []
for i in range(10):
sorted.mass = numpy.random.uniform(1.0, 2.0, number_of_particles) | nbody_system.mass
MSR = sorted.mass_segregation_from_nearest_neighbour(number_of_particles=10, number_of_random_sets=50)
MSR_of_nonsegregated_systems.append(MSR)
self.assertAlmostEquals((MSR_of_nonsegregated_systems|units.none).mean(), 1.0, 1)
self.assertAlmostEquals((MSR_of_nonsegregated_systems|units.none).std(), 0.3, 1)
sorted.mass = numpy.linspace(2.0, 1.0, number_of_particles) | nbody_system.mass
MSR, sigma = sorted.mass_segregation_from_nearest_neighbour(number_of_particles=10, number_of_random_sets=20,
also_compute_uncertainty=True)
self.assertTrue(MSR > 5.0)
if sys.hexversion > 0x03000000:
self.assertAlmostEquals(sigma, 0.3, 1)
else:
self.assertAlmostEquals(sigma, 0.4, 1)
def plummer_initial_conditions(n=128):
particles = new_plummer_sphere(n)
particles.scale_to_standard()
return particles
"""
def test6(self):
print "Test all particle attributes using Hop - each different function creates its own instance of Hop"
numpy.random.seed(123)
nbody_plummer = new_plummer_sphere(100)
nbody_plummer.mass = new_salpeter_mass_distribution_nbody(100)
# Each different function creates its own instance of Hop
result = nbody_plummer.new_particle_from_cluster_core(reuse_hop=True)
result = nbody_plummer.bound_subset(G=nbody_system.G, reuse_hop=True)
result = nbody_plummer.mass_segregation_Gini_coefficient(
reuse_hop=True)
result = nbody_plummer.LagrangianRadii(reuse_hop=True)
result = nbody_plummer.densitycentre_coreradius_coredens(
reuse_hop=True)
converter = nbody_system.nbody_to_si(1.0 | units.MSun,
1.0 | units.parsec)
si_plummer = ParticlesWithUnitsConverted(
nbody_plummer, converter.as_converter_from_si_to_nbody())
functions_using_hop = [
si_plummer.new_particle_from_cluster_core, si_plummer.bound_subset,
si_plummer.mass_segregation_Gini_coefficient,
si_plummer.LagrangianRadii,
si_plummer.densitycentre_coreradius_coredens
]
# Each fails since the Hop instance it tries to reuse has a different unit_converter
for function_using_hop in functions_using_hop:
self.assertRaises(
ConvertArgumentsException,
function_using_hop,
unit_converter=converter,
expected_message=
"error while converting parameter 'mass', error: Cannot express kg in mass, the units do not have the same bases"
)
# Close all Hop instances:
nbody_results = []
nbody_results.append(
nbody_plummer.new_particle_from_cluster_core(reuse_hop=False))
nbody_results.append(
nbody_plummer.bound_subset(G=nbody_system.G, reuse_hop=False))
nbody_results.append(
nbody_plummer.mass_segregation_Gini_coefficient(reuse_hop=False))
nbody_results.append(nbody_plummer.LagrangianRadii(reuse_hop=False))
nbody_results.append(
nbody_plummer.densitycentre_coreradius_coredens(reuse_hop=False))
# Now it works, because the Hop instances were closed, and new ones will be instantiated
si_results = []
for function_using_hop in functions_using_hop:
si_results.append(function_using_hop(unit_converter=converter))
convert = converter.as_converter_from_si_to_nbody()
self.assertAlmostRelativeEqual(
si_results[0].position,
ParticlesWithUnitsConverted(nbody_results[0].as_set(),
convert)[0].position)
self.assertAlmostRelativeEqual(
si_results[1].position,
ParticlesWithUnitsConverted(nbody_results[1], convert).position)
self.assertAlmostRelativeEqual(si_results[2],
nbody_results[2],
places=10)
self.assertAlmostRelativeEqual(si_results[3][0],
convert.from_target_to_source(
nbody_results[3][0]),
places=10)
for in_si, in_nbody in zip(si_results[4], nbody_results[4]):
self.assertAlmostRelativeEqual(
in_si, convert.from_target_to_source(in_nbody), places=10)
def create_particles(self):
self.particles = new_plummer_sphere(100)
def new_star_cluster(
stellar_mass=False,
initial_mass_function="salpeter",
upper_mass_limit=125. | units.MSun,
lower_mass_limit=0.1 | units.MSun,
number_of_stars=1024,
effective_radius=3.0 | units.parsec,
star_distribution="plummer",
star_distribution_w0=7.0,
star_distribution_fd=2.0,
star_metallicity=0.01,
# initial_binary_fraction=0,
**kwargs):
"""
Create stars.
When using an IMF, either the stellar mass is fixed (within
stochastic error) or the number of stars is fixed. When using
equal-mass stars, both are fixed.
"""
imf_name = initial_mass_function.lower()
if imf_name == "salpeter":
from amuse.ic.salpeter import new_salpeter_mass_distribution
initial_mass_function = new_salpeter_mass_distribution
elif imf_name == "kroupa":
from amuse.ic.brokenimf import new_kroupa_mass_distribution
initial_mass_function = new_kroupa_mass_distribution
elif imf_name == "flat":
from amuse.ic.flatimf import new_flat_mass_distribution
initial_mass_function = new_flat_mass_distribution
elif imf_name == "fixed":
from amuse.ic.flatimf import new_flat_mass_distribution
def new_fixed_mass_distribution(number_of_particles, *list_arguments,
**keyword_arguments):
return new_flat_mass_distribution(
number_of_particles,
mass_min=stellar_mass / number_of_stars,
mass_max=stellar_mass / number_of_stars,
)
initial_mass_function = new_fixed_mass_distribution
if stellar_mass:
# Add stars to cluster, until mass limit reached (inclusive!)
mass = initial_mass_function(
0,
mass_min=lower_mass_limit,
mass_max=upper_mass_limit,
)
while mass.sum() < stellar_mass:
mass.append(
initial_mass_function(
1,
mass_min=lower_mass_limit,
mass_max=upper_mass_limit,
)[0])
total_mass = mass.sum()
number_of_stars = len(mass)
else:
# Give stars their mass
mass = initial_mass_function(
number_of_stars,
mass_min=lower_mass_limit,
mass_max=upper_mass_limit,
)
total_mass = mass.sum()
converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(
total_mass,
1. | units.kms,
effective_radius,
)
# Give stars a position and velocity, based on the distribution model.
if star_distribution == "plummer":
stars = new_plummer_sphere(
number_of_stars,
convert_nbody=converter,
)
elif star_distribution == "king":
stars = new_king_model(
number_of_stars,
star_distribution_w0,
convert_nbody=converter,
)
elif star_distribution == "fractal":
stars = new_fractal_cluster_model(
number_of_stars,
fractal_dimension=star_distribution_fd,
convert_nbody=converter,
)
else:
return -1, "No stellar distribution"
# set the stellar mass.
stars.mass = mass
# set other stellar parameters.
stars.metallicity = star_metallicity
# Virialize the star cluster if > 1 star
if len(stars) > 1:
stars.move_to_center()
stars.scale_to_standard(
convert_nbody=converter,
# virial_ratio=virial_ratio,
# smoothing_length_squared= ...,
)
# Record the cluster's initial parameters to the particle distribution
stars.collection_attributes.initial_mass_function = imf_name
stars.collection_attributes.upper_mass_limit = upper_mass_limit
stars.collection_attributes.lower_mass_limit = lower_mass_limit
stars.collection_attributes.number_of_stars = number_of_stars
stars.collection_attributes.effective_radius = effective_radius
stars.collection_attributes.star_distribution = star_distribution
stars.collection_attributes.star_distribution_w0 = star_distribution_w0
stars.collection_attributes.star_distribution_fd = star_distribution_fd
stars.collection_attributes.star_metallicity = star_metallicity
# Derived/legacy values
stars.collection_attributes.converter_mass = \
converter.to_si(1 | nbody_system.mass)
stars.collection_attributes.converter_length =\
converter.to_si(1 | nbody_system.length)
stars.collection_attributes.converter_speed =\
converter.to_si(1 | nbody_system.speed)
return stars
#! /usr/bin/env python
#
import os, sys
try:
import amuse
#from amuse.community.bhtree.interface import BHTree
from amuse.datamodel import Particles
from amuse import datamodel
from amuse.units import nbody_system
from amuse.units import units
from amuse.ic.plummer import new_plummer_sphere
convert_nbody = nbody_system.nbody_to_si(100.0 | units.MSun,
1 | units.parsec)
n = 1000
plummer = new_plummer_sphere(n, convert_nbody)
stars = plummer.copy()
print('Plummer n=', n)
print('KE=', plummer.kinetic_energy())
print('PE=', plummer.potential_energy())
except:
print("Failing to load amuse modules")
sys.exit(1)
def create_particles(self):
self.particles = new_plummer_sphere(100)
