def test5(self):
print "Testing MI6 evolve_model, 2 particles, no SMBH"
particles = Particles(2)
particles.mass = 1.0 | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | units.km / units.s
particles[1].vy = (constants.G * (2.0 | units.MSun) /
(2.0 | units.AU)).sqrt()
particles.move_to_center()
print particles
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
instance = MI6(converter, **default_options)
instance.initialize_code()
instance.parameters.smbh_mass = 0.0 | units.MSun
instance.commit_parameters()
instance.particles.add_particles(particles)
instance.commit_particles()
primary = instance.particles[0]
P = 2 * math.pi * primary.x / primary.vy
position_at_start = primary.position.x
instance.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y,
3)
instance.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x,
3)
instance.evolve_model(P)
self.assertAlmostRelativeEqual(position_at_start, primary.position.x,
3)
instance.cleanup_code()
instance.stop()
def create_initial_wind_for_time(self, time, check_length=True):
"""
Particles are created as if the wind has already been blowing for
'time'. Note that this does not work if the mass loss is derived
from stellar evolution.
"""
self.model_time = time
self.particles.evolve_mass_loss(self.model_time)
if self.has_new_wind_particles():
wind_gas = self.create_wind_particles()
if self.has_target():
self.target_gas.add_particles(wind_gas)
elif check_length:
raise AmuseException("create_initial_wind time was too small to"
"create any particles.")
else:
wind_gas = Particles()
self.reset()
return wind_gas
def test2(self):
m_star = 0.666 | units.MSun
a_min = 666. | units.AU
a_max = 6666. | units.AU
q_min = 6. | units.AU
cloud = new_isotropic_cloud(66,
m_star=m_star,
a_min=a_min,
a_max=a_max,
q_min=q_min)
binary = Particles(1)
binary[0].mass = m_star
binary[0].position = (0., 0., 0.) | units.AU
binary[0].velocity = (0., 0., 0.) | units.kms
for comet in cloud:
binary.add_particle(comet)
mass1, mass2, semimajor_axis, eccentricity, true_anomaly, inclination, long_asc_node, arg_per = \
orbital_elements_from_binary(binary, G=constants.G)
print mass1, mass2, semimajor_axis, eccentricity, true_anomaly, inclination, long_asc_node, arg_per
self.assertTrue(a_min < semimajor_axis < a_max)
self.assertTrue(q_min < semimajor_axis * (1. - eccentricity))
binary.remove_particle(comet)
def copy_results(self, instance):
if self.name_of_the_code in self.sph_hydro_codes:
n_samples = self.number_of_grid_points * 3
result = Particles(n_samples)
result.position = [(x, 0.5, 0.5) | length
for x in numpy.linspace(0.0, 1.0, n_samples)]
x, y, z = result.x, result.y, result.z
if self.name_of_the_code == "fi":
x -= (0.5 | length)
y -= (0.5 | length)
z -= (0.5 | length)
no_speed = [0.0] * n_samples | speed
result.rho, result.rhovx, result.rhovy, result.rhovz, result.energy = [
self.convert_generic_units.to_generic(quantity)
for quantity in instance.get_hydro_state_at_point(
x, y, z, no_speed, no_speed, no_speed)
]
else:
result = []
for x in instance.itergrids():
result.append(x.copy())
return result
def test14b(self):
print("Testing basic operations: evolve_one_step and evolve_for (on subset)")
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = SSE()
se_stars = instance.particles.add_particles(stars)
self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr)
for i in range(3):
se_stars[:1].evolve_one_step()
self.assertAlmostEqual(se_stars.age, [1650.46953688, 0.0] | units.Myr, 3)
number_of_steps = 10
step_size = se_stars[0].age / number_of_steps
for i in range(1, number_of_steps + 1):
se_stars[1:].evolve_for(step_size)
self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size)
print(se_stars)
self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age)
self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3)
self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3)
self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3)
instance.stop()
def test1(self):
print "Test basic particle attributes and scale_to_standard - nbody units"
particles = Particles(2)
particles.position = [[-1, 0, 0], [1, 0, 0]] | nbody_system.length
particles.velocity = [[-1, 0, 0], [1, 0, 0]
] | nbody_system.length / nbody_system.time
particles.mass = 0.4 | nbody_system.mass
self.assertAlmostRelativeEquals(particles.total_mass(),
0.8 | nbody_system.mass)
self.assertAlmostRelativeEquals(particles.kinetic_energy(),
0.4 | nbody_system.energy)
self.assertAlmostRelativeEquals(
particles.potential_energy(G=nbody_system.G),
-0.08 | nbody_system.energy)
self.assertAlmostRelativeEquals(particles.virial_radius(),
4.0 | nbody_system.length)
particles.scale_to_standard()
self.assertAlmostRelativeEquals(particles.total_mass(),
1.0 | nbody_system.mass)
self.assertAlmostRelativeEquals(particles.kinetic_energy(),
0.25 | nbody_system.energy)
self.assertAlmostRelativeEquals(
particles.potential_energy(G=nbody_system.G),
-0.5 | nbody_system.energy)
self.assertAlmostRelativeEquals(particles.virial_radius(),
1.0 | nbody_system.length)
particles.scale_to_standard(virial_ratio=1) # unbound
self.assertAlmostRelativeEquals(particles.kinetic_energy(),
0.5 | nbody_system.energy)
self.assertAlmostRelativeEquals(
particles.potential_energy(G=nbody_system.G),
-0.5 | nbody_system.energy)
particles.scale_to_standard(virial_ratio=0) # velocities zeroed
self.assertAlmostRelativeEquals(particles.kinetic_energy(),
0 | nbody_system.energy)
self.assertAlmostRelativeEquals(
particles.potential_energy(G=nbody_system.G),
-0.5 | nbody_system.energy)
def test56(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path,
"test26" + self.store_version() + ".hdf5")
if os.path.exists(output_file):
os.remove(output_file)
number_of_particles = 10
p = Particles(number_of_particles)
p.mass = [x * 2.0 for x in range(number_of_particles)] | units.kg
p.model_time = 2.0 | units.s
gas = Grid(2, 3)
gas.y = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] | units.km
io.write_set_to_file(p,
output_file,
"hdf5",
particle=p[1],
particles=p,
gridpoint=gas[0][0],
grid=gas,
version=self.store_version())
loaded_particles = io.read_set_from_file(output_file,
"hdf5",
version=self.store_version(),
copy_history=False,
close_file=False)
attributes = loaded_particles.collection_attributes
self.assertAlmostRelativeEquals(attributes.particle.mass,
loaded_particles[1].mass)
self.assertEquals(attributes.particle.key, loaded_particles[1].key)
self.assertEquals(id(attributes.particles), id(loaded_particles))
self.assertAlmostRelativeEquals(attributes.gridpoint.y, 1.0 | units.km)
self.assertAlmostRelativeEquals(attributes.grid[0][0].y,
1.0 | units.km)
def test7(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "test7"+self.store_version()+".hdf5")
if os.path.exists(output_file):
os.remove(output_file)
instance = self.store_factory()(output_file)
number_of_particles = 10
p = Particles(number_of_particles)
p.mass = [x * 2.0 for x in range(number_of_particles)] | units.kg
p.model_time = 2.0 | units.s
instance.store(p)
instance.close()
instance = self.store_factory()(output_file)
loaded_particles = self.get_version_in_store(instance.load())
loaded_particles.mass = [x * 3.0 for x in range(number_of_particles)] | units.kg
previous_mass_in_kg = [x * 3.0 for x in range(number_of_particles)]
instance.close()
instance = self.store_factory()(output_file)
loaded_particles = instance.load()
loaded_mass_in_kg = loaded_particles.mass.value_in(units.kg)
for expected, actual in zip(previous_mass_in_kg, loaded_mass_in_kg):
self.assertEquals(expected, actual)
instance.close()
instance = self.store_factory()(output_file)
loaded_particles = self.get_version_in_store(instance.load())
loaded_particles[2].mass = 44 | units.kg
instance.close()
instance = self.store_factory()(output_file)
loaded_particles = self.get_version_in_store(instance.load())
self.assertEquals( 44 | units.kg, loaded_particles[2].mass)
instance.close()
def test11(self):
print "Test that a source is not included when calculating gravity on itself."
number_of_sources = 100
mass, length, G = nbody_system.mass, nbody_system.length, nbody_system.G
sources = Particles(mass=numpy.ones(number_of_sources) | mass,
x=0 | length,
y=0 | length,
z=0 | length)
point = Particle(x=0 | length, y=0 | length, z=1.0 | length)
instance = self.new_fastkick_instance()
instance.particles.add_particles(sources)
potential = instance.get_potential_at_point(0 | length, point.x,
point.y, point.z)
ax, ay, az = instance.get_gravity_at_point(0 | length, point.x,
point.y, point.z)
self.assertAlmostEqual(ax, G * (0 | mass / length**2), 5)
self.assertAlmostEqual(ay, G * (0 | mass / length**2), 5)
self.assertAlmostRelativeEqual(az,
-G * sources.total_mass() / point.z**2,
3)
self.assertAlmostRelativeEqual(potential,
-G * sources.total_mass() / point.z, 3)
point.mass = 1e6 | mass
instance.particles.add_particle(point)
potential = instance.get_potential_at_point(0 | length, point.x,
point.y, point.z)
ax, ay, az = instance.get_gravity_at_point(0 | length, point.x,
point.y, point.z)
self.assertAlmostEqual(ax, G * (0 | mass / length**2), 5)
self.assertAlmostEqual(ay, G * (0 | mass / length**2), 5)
self.assertAlmostRelativeEqual(az,
-G * sources.total_mass() / point.z**2,
3)
self.assertAlmostRelativeEqual(potential,
-G * sources.total_mass() / point.z, 3)
instance.stop()
def test7(self):
instance = self.new_fastkick_instance()
instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2
particles = Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]
] | nbody_system.length
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
ax, ay, az = instance.get_gravity_at_point(zero,
1.0 | nbody_system.length,
zero, zero)
self.assertAlmostEqual(ax, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(ay, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(az, 0.0 | nbody_system.acceleration, 6)
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
x1 = (2.0 - x) | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
potential1 = instance.get_potential_at_point(zero, x1, zero, zero)
ax0, ay0, az0 = instance.get_gravity_at_point(zero, x0, zero, zero)
ax1, ay1, az1 = instance.get_gravity_at_point(zero, x1, zero, zero)
self.assertAlmostEqual(ay0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(az0, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(ay1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(az1, 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(ax0, -ax1, 5)
ax = (-1.0 / (x0**2) + 1.0 /
(x1**2)) * (1.0
| nbody_system.length**3 / nbody_system.time**2)
self.assertAlmostEqual(ax, ax0, 2)
self.assertAlmostEqual(potential0, potential1, 5)
instance.stop()
def initialize_multiple_system(N_bodies, masses, semimajor_axis, eccentricity,
inclination, argument_of_pericenter,
longitude_of_ascending_node):
N_binaries = N_bodies - 1
particles = Particles(N_bodies + N_binaries)
for index in range(N_bodies):
particle = particles[index]
particle.mass = masses[index]
particle.is_binary = False
particle.radius = 1.0 | units.RSun
particle.child1 = None
particle.child2 = None
for index in range(N_binaries):
particle = particles[index + N_bodies]
particle.is_binary = True
particle.semimajor_axis = semimajor_axis[index]
particle.eccentricity = eccentricity[index]
particle.inclination = inclination[index]
particle.argument_of_pericenter = argument_of_pericenter[index]
particle.longitude_of_ascending_node = longitude_of_ascending_node[
index]
# Specify the `2+2' hierarchy:
if index == 0:
particle.child1 = particles[0]
particle.child2 = particles[1]
elif index == 1:
particle.child1 = particles[2]
particle.child2 = particles[3]
elif index == 2:
particle.child1 = particles[4]
particle.child2 = particles[5]
binaries = particles[particles.is_binary]
return particles, binaries
def test3(self):
particles = Particles(10)
particles.mass = list(range(10)) | units.kg
particles[0].child1 = particles[1]
particles[0].child2 = particles[2]
particles[1].child1 = particles[3]
particles[1].child2 = particles[4]
particles[2].child1 = particles[5]
particles[2].child2 = particles[6]
tree = particles.as_binary_tree()
self.assertFalse(tree.is_leaf())
self.assertEqual(len(list(tree.iter_children())), 4)
self.assertEqual(len(list(tree.iter_branches())), 1)
self.assertEqual(len(list(tree.iter_leafs())), 3)
self.assertEqual(len(list(tree.iter_descendant_leafs())), 7)
self.assertEqual(len(list(tree.iter_descendant_branches())), 3)
branches = list(tree.iter_branches())
self.assertEqual(len(list(branches[0].iter_children())), 2)
self.assertEqual(len(list(branches[0].iter_branches())), 2)
self.assertEqual(len(list(branches[0].iter_leafs())), 0)
self.assertEqual(len(list(branches[0].iter_descendant_leafs())), 4)
self.assertEqual(len(list(branches[0].iter_descendant_branches())), 2)
def evolve_with_kepler(self, hydro):
if self.verbose: print "evolve_with_kepler"
indices_two_most_massive = self.stars_after_encounter.mass.argsort(
)[-2:]
groups = [
self.groups_after_encounter[i] for i in indices_two_most_massive
]
old_particles = self.stars_after_encounter[indices_two_most_massive]
new_particles = Particles(2)
new_particles.mass = old_particles.mass
new_particles[0].position, new_particles[
0].velocity = self.skip_to_relative_position_velocity
new_particles.move_to_center()
for group, old_particle, new_particle in zip(groups, old_particles,
new_particles):
in_hydro = group.get_intersecting_subset_in(hydro.gas_particles)
if self.verbose:
print in_hydro.center_of_mass().as_quantity_in(
units.RSun), old_particle.position.as_quantity_in(
units.RSun), new_particle.position.as_quantity_in(
units.RSun)
in_hydro.position += new_particle.position - old_particle.position
in_hydro.velocity += new_particle.velocity - old_particle.velocity
def wind_sphere(self, star, Ngas):
wind = Particles(Ngas)
dt = (self.model_time - star.wind_release_time)
if self.critical_timestep is None or dt > self.critical_timestep:
acc_function = self.acc_function
else:
acc_function = ConstantVelocityAcceleration(use_initial=True)
outer_wind_distance = acc_function.radius_from_time(dt, star)
wind.position, direction = self.generate_positions(
Ngas,
star.radius,
outer_wind_distance,
acc_function.radius_from_number,
star=star)
velocities = acc_function.velocity_from_radius(wind.position.lengths(),
star)
wind.velocity = direction * self.as_three_vector(velocities)
return wind
def test3(self):
print "Test CollisionHandler with collision code class, arguments and parameters"
colliders = Particles(2)
handler = CollisionHandler(
CollisionCodeForTesting,
collision_code_arguments=dict(next_mass=5|units.kg),
collision_code_parameters=dict(mass_unit=units.g)
)
result = handler.handle_collision(colliders[0], colliders[1])
self.assertTrue(isinstance(result, Particles))
self.assertEqual(result.mass, 5 | units.kg)
self.assertTrue(result.mass.unit is units.g)
result = handler.handle_collision(colliders[0], colliders[1])
self.assertEqual(result.mass, 5 | units.kg)
self.assertTrue(result.mass.unit is units.g)
handler.collision_code_arguments = dict(next_mass=42|units.kg)
handler.collision_code_parameters = dict(mass_unit=units.MSun)
result = handler.handle_collision(colliders[0], colliders[1])
self.assertEqual(result.mass, 42 | units.kg)
self.assertTrue(result.mass.unit is units.MSun)
def new_plummer_spatial_distribution(number_of_particles,
total_mass = 1.0|nbody_system.mass,
virial_radius = 1.0|nbody_system.length,
mass_cutoff = 0.999,
**keyword_arguments): # optional arguments for UniformSphericalDistribution
"""
Returns a Particles set with positions following a Plummer
distribution.
Only the positions and masses (equal-mass system) are set.
"""
particles = Particles(number_of_particles)
particle_mass = total_mass * 1.0 / number_of_particles
particles.mass = particle_mass
x, y, z = UniformSphericalDistribution(
number_of_particles, mass_cutoff=mass_cutoff, **keyword_arguments).result
# Now scale the uniformly distributed particle positions to match the radial density profile
r_old = numpy.sqrt(x*x + y*y + z*z)
scale_factor = (0.1875 * numpy.pi * virial_radius.number) / numpy.sqrt(1.0 - r_old**2)
particles.x = scale_factor * x | virial_radius.unit
particles.y = scale_factor * y | virial_radius.unit
particles.z = scale_factor * z | virial_radius.unit
return particles
def test7(self):
print("Test: evolve particles one at a time.")
print(
"Used to be problematic, since initial_mass of idle particle is set to zero."
)
stars = Particles(2)
stars.mass = 1.0 | units.MSun
for star in stars:
stellar_evolution = SSE()
stellar_evolution.commit_parameters()
stellar_evolution.particles.add_particles(star.as_set())
stellar_evolution.commit_particles()
from_stellar_evolution_to_model = stellar_evolution.particles.new_channel_to(
star.as_set())
stellar_evolution.evolve_model()
from_stellar_evolution_to_model.copy()
stellar_evolution.stop()
self.assertEqual(stars[0].initial_mass, stars[1].initial_mass)
self.assertEqual(stars[0].luminosity, stars[1].luminosity)
self.assertEqual(stars[0].age, stars[1].age)
print(
"Solved: SSE_muse_interface.f sets initial_mass to mass when necessary."
)
def test3(self):
print "Testing sun recreation"
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
stars = Particles(1)
stars.mass = 1 | units.MSun
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEquals(instance.particles.mass, 1 | units.MSun)
self.assertAlmostEquals(instance.particles.luminosity, 0.7098065 | units.LSun, 6)
self.assertAlmostEquals(instance.particles.radius, 0.8892833 | units.RSun, 6)
instance.evolve_model(4.8|units.Gyr)
self.assertAlmostEquals(instance.particles.mass, 0.999921335 | units.MSun, 6)
self.assertAlmostEquals(instance.particles.luminosity, 1.04448714 | units.LSun, 6)
self.assertAlmostEquals(instance.particles.radius, 1.02061451 | units.RSun, 6)
instance.stop()
def create_binary(m1, m2, a, e, i, g, h):
particles = Particles(3)
for index in range(2):
particle = particles[index]
particle.is_binary = False
if index == 0:
particle.mass = m1
else:
particle.mass = m2
particle.child1 = None
particle.child2 = None
particles[2].is_binary = True
particles[2].semimajor_axis = a
particles[2].eccentricity = e
particles[2].inclination = i
particles[2].argument_of_pericenter = g
particles[2].longitude_of_ascending_node = h
particles[2].child1 = particles[0]
particles[2].child2 = particles[1]
return particles
def wind_sphere(self, star, Ngas):
wind = Particles(Ngas)
wind_velocity = star.initial_wind_velocity
outer_wind_distance = star.radius + wind_velocity * (
self.model_time - star.wind_release_time)
if self.r_max is not None and outer_wind_distance < self.r_max:
outer_wind_distance = self.r_max
wind.position, direction = self.generate_positions(
Ngas, star.radius, outer_wind_distance)
if self.compensate_gravity:
r = wind.position.lengths()
escape_velocity_squared = 2. * constants.G * star.mass / r
speed = (wind_velocity**2 + escape_velocity_squared).sqrt()
wind.velocity = self.as_three_vector(speed) * direction
else:
wind.velocity = direction * wind_velocity
return wind
def test2(self):
""" Test Spheroid sink accretion """
particles = self.create_particle_grid()
spheroid = sink.Spheroid([5., 4., 1.]|units.RSun)
sink_particles = Particles(1, mass=10.|units.MSun, radius=0.|units.RSun, position=[[1., 1., 1.]]|units.RSun)
sinks = new_sink_particles(sink_particles, shapes=spheroid)
accreted = sinks.accrete(particles)
self.assertEqual(len(accreted), 161)
self.assertEqual(len(particles), 1839)
self.assertEqual(accreted.x.max(), 4|units.RSun)
self.assertEqual(accreted.y.max(), 3|units.RSun)
self.assertEqual(accreted.z.max(), 0.5|units.RSun)
spheroid.dimensions[2] = 3 | units.RSun
accreted = sinks.accrete(particles)
self.assertEqual(len(accreted), 324)
self.assertEqual(len(particles), 1515)
self.assertEqual(accreted.x.max(), 4|units.RSun)
self.assertEqual(accreted.y.max(), 3|units.RSun)
self.assertEqual(accreted.z.max(), 2.5|units.RSun)
self.assertIsSubvector([3, 2, 2.5]|units.RSun, particles.position)
def add_comets(star, m_comets, n_comets, q_min, q_max, a_min, a_max, seed):
cloud_xyz = generate_primordial_oort_cloud(star.mass, n_comets, q_min, q_max, a_min, a_max, seed)
masses = new_salpeter_mass_distribution(n_comets, 0.1|units.MSun, 100|units.MSun)
masses = m_comets*masses/masses.sum()
print("total mass in comets: M=", masses.sum().in_(units.MEarth))
comets = Particles(n_comets)
comets.mass = masses
comets.name = "comet"
comets.type = "comet"
comets.host = star
comets.x = cloud_xyz[:,2] | units.au
comets.y = cloud_xyz[:,3] | units.au
comets.z = cloud_xyz[:,4] | units.au
comets.vx = cloud_xyz[:,5] | 2*numpy.pi*units.au/units.yr
comets.vy = cloud_xyz[:,6] | 2*numpy.pi*units.au/units.yr
comets.vz = cloud_xyz[:,7] | 2*numpy.pi*units.au/units.yr
comets.position += star.position
comets.velocity += star.velocity
return comets
def test12(self):
print "Testing adding and removing particles from stellar evolution code..."
particles = Particles(3)
particles.mass = 1.0 | units.MSun
instance = MOSSE()
instance.initialize_code()
instance.commit_parameters()
self.assertEquals(len(instance.particles), 0) # before creation
instance.particles.add_particles(particles[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEquals(len(instance.particles), 2) # before remove
self.assertAlmostEqual(instance.particles.age, 1.0 | units.Myr)
instance.particles.remove_particle(particles[0])
self.assertEquals(len(instance.particles), 1)
instance.evolve_model(2.0 | units.Myr)
self.assertAlmostEqual(instance.particles[0].age, 2.0 | units.Myr)
instance.particles.add_particles(particles[::2])
self.assertEquals(len(instance.particles), 3) # it's back...
self.assertAlmostEqual(instance.particles[0].age, 2.0 | units.Myr)
self.assertAlmostEqual(instance.particles[1].age, 0.0 | units.Myr)
self.assertAlmostEqual(instance.particles[2].age,
0.0 | units.Myr) # ... and rejuvenated.
instance.evolve_model(
3.0 | units.Myr
) # The young stars keep their age offset from the old star
self.assertAlmostEqual(instance.particles.age,
[3.0, 1.0, 1.0] | units.Myr)
instance.evolve_model(4.0 | units.Myr)
self.assertAlmostEqual(instance.particles.age,
[4.0, 2.0, 2.0] | units.Myr)
instance.stop()
def test14(self):
print "Testing EVtwin states"
stars = Particles(2)
stars.mass = 1.0 | units.MSun
instance = EVtwin()
print "First do everything manually:",
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_particle(stars[0])
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 "ok"
print "initialize_code(), commit_parameters(), (re)commit_particles(), " \
"and cleanup_code() should be called automatically:",
instance = EVtwin()
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.RGB_wind_setting = -0.5
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particle(stars[0])
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.add_particle(stars[1])
self.assertEquals(instance.get_name_of_current_state(), 'UPDATE')
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')
print "ok"
def xslowtest11(self):
print "Test 11: Continue the stellar evolution of a 'merger product' - WIP"
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
instance.parameters.min_timestep_stop_condition = 1.0 | units.s
stars = Particles(3)
stars.mass = [1.0, 2.0, 1.0] | units.MSun
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
stellar_models = instance.native_stars.get_internal_structure()
self.assertEqual(len(stellar_models), 3)
self.assertEqual(len(stellar_models[0]), 199)
self.assertEqual(len(stellar_models[1]), 199)
self.assertAlmostEqual(stellar_models[0].mass[198], 1.0 | units.MSun, 2)
self.assertAlmostEqual(stellar_models[1].mass[198], 2.0 | units.MSun, 2)
self.assertAlmostEqual(stellar_models[0].mass[0], 0.0 | units.MSun, 2)
instance.new_particle_from_model(stellar_models[0], instance.particles[0].age)
self.assertEqual(len(instance.particles), 4)
self.assertEqual(len(instance.imported_stars), 1)
imported_stellar_model = instance.imported_stars[0].get_internal_structure()
self.assertEqual(len(imported_stellar_model), 199)
self.assertAlmostEqual(imported_stellar_model.mass[198], 1.0 | units.MSun, 2)
self.assertAlmostEqual(imported_stellar_model.mass[0], 0.0 | units.MSun, 2)
self.assertAlmostRelativeEqual(imported_stellar_model.X_H, stellar_models[0].X_H, 5)
self.assertAlmostRelativeEqual(imported_stellar_model.X_He, stellar_models[0].X_He, 5)
self.assertAlmostRelativeEqual(imported_stellar_model.mass, stellar_models[0].mass, 2)
self.assertAlmostRelativeEqual(imported_stellar_model.radius[1:], stellar_models[0].radius[1:], 2)
# instance.evolve_model(2.0 | units.Myr)
print instance.particles
instance.stop()
del instance
def create_triple(m1, m2, m3, a_in, a_out, e_in, e_out, i_in, i_out, g_in,
g_out, h_in, h_out):
N_bodies = 3
N_binaries = 2
m_list = [m1, m2, m3]
a_list = [a_in, a_out]
e_list = [e_in, e_out]
i_list = [i_in, i_out]
g_list = [g_in, g_out]
h_list = [h_in, h_out]
particles = Particles(N_bodies + N_binaries)
for index in range(N_bodies):
particle = particles[index]
particle.is_binary = False
particle.mass = m_list[index]
particle.child1 = None
particle.child2 = None
for index in range(N_binaries):
particles[index + N_bodies].is_binary = True
particles[index + N_bodies].semimajor_axis = a_list[index]
particles[index + N_bodies].eccentricity = e_list[index]
particles[index + N_bodies].inclination = i_list[index]
particles[index + N_bodies].argument_of_pericenter = g_list[index]
particles[index + N_bodies].longitude_of_ascending_node = h_list[index]
if index == 0:
particles[index + N_bodies].child1 = particles[0]
particles[index + N_bodies].child2 = particles[1]
elif index == 1:
particles[index + N_bodies].child1 = particles[2]
particles[index + N_bodies].child2 = particles[3]
return particles
def test3(self):
print(
"Testing SinkParticles initialization from existing particles in set"
)
particles = Particles(10)
self.assertRaises(
AttributeError,
SinkParticles,
particles[[4, 7]],
expected_message=
"You tried to access attribute 'radius' but this attribute is not defined for this set."
)
particles.radius = 42.0 | units.RSun
particles.mass = list(range(1, 11)) | units.MSun
particles.position = [[i, 2 * i, 3 * i]
for i in range(10)] | units.parsec
sinks = SinkParticles(particles[[4]])
self.assertEqual(sinks.mass, 5.0 | units.MSun)
self.assertEqual(sinks.sink_radius, 42.0 | units.RSun)
self.assertEqual(sinks.radius, 42.0 | units.RSun)
self.assertEqual(sinks.position, [4.0, 8.0, 12.0] | units.parsec)
sinks = SinkParticles(particles[[4, 7]], sink_radius=[1, 2] | units.AU)
self.assertEqual(sinks.sink_radius, [1.0, 2.0] | units.AU)
self.assertEqual(sinks.radius, 42.0 | units.RSun)
self.assertEqual(sinks.mass, [5.0, 8.0] | units.MSun)
self.assertEqual(sinks.position,
[[4, 8, 12], [7, 14, 21]] | units.parsec)
self.assertEqual(
set([
'key', 'mass', 'radius', 'x', 'y', 'z', 'sink_radius', 'vx',
'vy', 'vz', 'lx', 'ly', 'lz'
]), set(str(sinks).split("\n")[0].split()))
self.assertEqual(set(['key', 'mass', 'radius', 'x', 'y', 'z']),
set(str(particles).split("\n")[0].split()))
def test2(self):
print("Demonstrate new_sink_particles usage")
cloud = Particles(100)
cloud.mass = 1 | units.MSun
cloud.position = [[0, 0, 0], [100, 100, 100], [200, 200, 200], [300, 300, 300]]*25 | units.parsec
cloud.velocity = [[0, 0, 0], [1, 1, 1]]*50 | units.km / units.s
unit_converter = ConvertBetweenGenericAndSiUnits(1|units.m, 1|units.kg, 1|units.s)
sph_code = Stub(unit_converter)
sph_code.parameters.stopping_condition_maximum_density = 1 | units.kg / units.m**3
sph_code.gas_particles.add_particles(cloud)
density_limit_detection = sph_code.stopping_conditions.density_limit_detection
density_limit_detection.enable()
sph_code.evolve_model(1 | units.Myr)
self.assertTrue(density_limit_detection.is_set())
self.assertEqual(len(density_limit_detection.particles()), 3)
self.assertEqual(density_limit_detection.particles().position,
[[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec)
print(density_limit_detection.particles())
clumps = density_limit_detection.particles().copy()
sph_code.gas_particles.remove_particles(clumps)
sinks = new_sink_particles(clumps, sink_radius=1|units.parsec,looping_over=self.looping_over)
self.assertEqual(sinks.sink_radius, 1.0 | units.parsec)
self.assertEqual(sinks.mass, 1.0 | units.MSun)
self.assertEqual(sinks.position,
[[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec)
self.assertEqual(len(sph_code.gas_particles), 97)
self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10)
self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 97 | units.MSun, 10)
sinks.accrete(sph_code.gas_particles)
self.assertAlmostRelativeEqual(sinks.mass, [25, 25, 25] | units.MSun, 10)
self.assertEqual(len(sph_code.gas_particles), 25)
self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10)
self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 25 | units.MSun, 10)
def split_subcodes(self):
subsystems = self.particles.compound_particles()
to_remove = Particles()
sys_to_add = []
for parent in subsystems:
subsys = parent.subsystem
radius = parent.radius
components = subsys.connected_components(threshold=self.threshold,
distfunc=self.distfunc)
if len(components) > 1:
#print("splitting:", len(components))
parentposition = parent.position
parentvelocity = parent.velocity
to_remove.add_particle(parent)
for c in components:
sys = c.copy()
sys.position += parentposition
sys.velocity += parentvelocity
sys_to_add.append(sys)
code = self.subcodes.pop(parent)
del code
if len(to_remove) > 0:
self.particles.remove_particles(to_remove)
for sys in sys_to_add:
if len(sys) > 1:
newcode = self.subcode_factory(sys)
newcode.parameters.begin_time = self.model_time
newcode.particles.add_particles(sys)
newparent = self.particles.add_subsystem(newcode.particles)
newparent.sub_worker_radius = 0. * newparent.radius
self.subcodes[newparent] = newcode
else:
newparent = self.particles.add_subsystem(sys)
newparent.sub_worker_radius = sys[0].radius
self.set_parent_particle_radius(newparent)
def evolve_bridged_orbit_in_potential(potential, cluster, code, timestep,
current_age):
orbit = static_potentials.Position_In_Potential(potential, cluster)
bridge, gravity, gravity_to_orbit = setup_bridge(
potential, cluster, current_age, timestep, orbit, code)
print(current_age, "->", orbit.particle.position)
# Evolving backward
gravity.particles.velocity *= -1
while bridge.model_time < current_age - (timestep / 2.):
# print bridge.model_time, "-", gravity.particles.position[0]
bridge.evolve_model(bridge.model_time + timestep)
gravity_to_orbit.copy()
gravity.particles.velocity *= -1
gravity.model_time = 0 | units.Myr
bridge.time = 0 | units.Myr
cluster = gravity.particles[0]
orbit.particle = cluster
bridge, gravity, gravity_to_orbit = setup_bridge(
potential, cluster, current_age, timestep, orbit, code)
print(bridge.model_time, "->", orbit.particle.position)
# Evolving forward
full_orbit = Particles()
while bridge.model_time < current_age - (timestep / 2.):
full_orbit.add_particle(orbit.particle.copy())
bridge.evolve_model(bridge.model_time + timestep)
gravity_to_orbit.copy()
full_orbit.add_particle(orbit.particle.copy())
print(bridge.model_time, "->", orbit.particle.position)
full_orbit.position -= coordinate_correction
return full_orbit
