def makeparts(self,N):
parts=Particles(N)
numpy.random.seed(1234567)
parts.number_density=(numpy.random.random(N)*1.e5+1.e5)| units.cm**-3
parts.temperature=(numpy.random.random(N)*500+100)| units.K
parts.ionrate=(numpy.random.random(N)*1.e-11+1.e-17)| units.s**-1
return parts
def test5(self):
sse = SSE()
sse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 35 | units.MSun
star.radius = 0.0 | units.RSun
stars.synchronize_to(sse.particles)
channel = sse.particles.new_channel_to(stars)
channel.copy_attributes(sse.particles.get_attribute_names_defined_in_store())
previous_type = star.stellar_type
results = []
dt = 1 | units.Myr
t = 0 | units.Myr
while t < 30 | units.Myr:
t += dt
sse.evolve_model(t)
self.assertTrue(sse.particles[0].mass.value_in(units.MSun) < 10.6)
sse.stop()
def test4(self):
print "test4: evolve test (10 part)"
instance=self.new_instance_of_an_optional_code(Krome,**default_options)
parts=Particles(10)
parts.number_density=1.e5 | units.cm**-3
parts.temperature=50 | units.K
parts.ionrate=2.e-17 | units.s**-1
Ns=len(instance.species)
parts.abundances=numpy.zeros((1,Ns))
instance.particles.add_particles(parts)
instance.evolve_model( 1. | units.Myr )
f=2*instance.particles[0].abundances[instance.species["H2"]]
self.assertTrue(f> 0.95) # not much of a test..
#~ for x,i in instance.species.items():
#~ print x, instance.particles[0].abundances[i]
instance.cleanup_code()
instance.stop()
def result(self): masses, position_vectors, velocity_vectors = self.new_model() result = Particles(self.targetN) result.mass = masses result.position = position_vectors result.velocity = velocity_vectors return result
def test11(self):
print "Test evolve_model optional arguments: end_time and keep_synchronous"
stars = Particles(3)
stars.mass = [1.0, 2.0, 3.0] | units.MSun
instance = SSE()
instance.commit_parameters()
instance.particles.add_particles(stars)
self.assertEqual(instance.particles.age, [0.0, 0.0, 0.0] | units.yr)
self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.particles.radius, [0.8882494502, 1.610210385, 1.979134445] | units.RSun)
print "evolve_model without arguments: use shared timestep = min(particles.time_step)"
instance.evolve_model()
self.assertAlmostEqual(instance.particles.age, [18.8768, 18.8768, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.model_time, 18.8768 | units.Myr, 3)
print "evolve_model with end_time: take timesteps, until end_time is reached exactly"
instance.evolve_model(100 | units.Myr)
self.assertAlmostEqual(instance.particles.age, [100.0, 100.0, 100.0] | units.Myr, 3)
self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 3)
print "evolve_model with keep_synchronous: use non-shared timestep, particle ages will typically diverge"
instance.evolve_model(keep_synchronous = False)
self.assertAlmostEqual(instance.particles.age, (100 | units.Myr) + ([550.1565, 58.2081, 18.8768] | units.Myr), 3)
self.assertAlmostEqual(instance.particles.time_step, [550.1565, 58.2081, 18.8768] | units.Myr, 3)
self.assertAlmostEqual(instance.model_time, 100.0 | units.Myr, 3) # Unchanged!
instance.stop()
def test7(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]
x = trees.BinaryTreesOnAParticleSet(particles, "child1", "child2")
roots = list(x.iter_roots())
self.assertEquals(len(roots), 1)
binary = roots[0]
output = ''
for level, particle in binary.iter_levels():
output += '..' * level
output += str(particle.mass.value_in(units.kg))
output += '\n'
print output
self.assertEquals(output, """0.0
..1.0
....3.0
....4.0
..2.0
""")
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.position = [[0.0, 0.0, 0.0], [1.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 * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test13(self):
print "Testing SSE states"
stars = Particles(1)
stars.mass = 1.0 | units.MSun
print "First do everything manually:",
instance = SSE()
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(), 'RUN')
instance.cleanup_code()
self.assertEquals(instance.get_name_of_current_state(), 'END')
instance.stop()
print "ok"
print "initialize_code(), commit_parameters(), " \
"and cleanup_code() should be called automatically:",
instance = SSE()
self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED')
instance.parameters.reimers_mass_loss_coefficient = 0.5
self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED')
instance.particles.add_particles(stars)
self.assertEquals(instance.get_name_of_current_state(), 'RUN')
instance.stop()
self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
print "ok"
def setup_stellar_evolution_model():
out_pickle_file = os.path.join(
get_path_to_results(), "super_giant_stellar_structure.pkl")
if os.path.exists(out_pickle_file):
return out_pickle_file
stellar_evolution = MESA(redirection="none")
stars = Particles(1)
stars.mass = 10.0 | units.MSun
stellar_evolution.initialize_module_with_default_parameters()
stellar_evolution.particles.add_particles(stars)
stellar_evolution.commit_particles()
print(
"Evolving a MESA star with mass:",
stellar_evolution.particles[0].mass
)
try:
while True:
stellar_evolution.evolve_model()
except AmuseException as ex:
print "Evolved star to", stellar_evolution.particles[0].age
print "Radius:", stellar_evolution.particles[0].radius
pickle_stellar_model(stellar_evolution.particles[0], out_pickle_file)
stellar_evolution.stop()
return out_pickle_file
def test6(self):
particles = Particles(2)
particles.add_attribute_domain('a')
particles.add_attribute_domain('b')
def set_a():
particles[0].a = 1 | units.kg
self.assertRaises(AttributeError, set_a)
def setup_stellar_evolution_model():
out_pickle_file = os.path.join(get_path_to_results(), "super_giant_stellar_structure.pkl")
if os.path.exists(out_pickle_file):
return out_pickle_file
stellar_evolution = MESA(redirection="none")
stars = Particles(1)
stars.mass = 10.0 | units.MSun
stellar_evolution.particles.add_particles(stars)
"""
print "Evolving a MESA star with mass:", stellar_evolution.particles[0].mass
try:
while True:
stellar_evolution.evolve_model()
except AmuseException as ex:
print "Evolved star to t=", stellar_evolution.particles[0].age,
print "Mass:", stellar_evolution.particles[0].mass
print "Radius:", stellar_evolution.particles[0].radius
print "core-mass:", stellar_evolution.particles[0].core_mass
"""
while stellar_evolution.particles[0].stellar_type <= 12 | units.stellar_type:
stellar_evolution.evolve_model()
pickle_stellar_model(stellar_evolution.particles[0], out_pickle_file)
stellar_evolution.stop()
return out_pickle_file
def new_sun_earth_system():
particles = Particles(2)
particles.mass = [1, 0.2] | units.MSun
particles.position = [[0, 0, 0], [1.0, 0, 0]] | units.AU
particles.velocity = [0, 0, 0] | units.km / units.s
particles[1].vy = (constants.G * particles.total_mass() / particles[1].x).sqrt()
return particles
def slowtest11(self):
print "Test for importing new stellar models, also check long-term evolution"
instance = EVtwin()
instance.parameters.verbosity = True
instance.particles.add_particles(Particles(mass = [0.8] | units.MSun))
instance.evolve_model()
copy = Particles(1)
copy.internal_structure = instance.particles[0].get_internal_structure()
instance.particles.add_particles(copy)
number_of_zones = instance.particles[0].get_number_of_zones()
self.assertEqual(len(instance.particles), 2)
self.assertEqual(instance.particles[1].get_number_of_zones(), number_of_zones)
self.assertIsOfOrder(instance.particles[1].get_radius_profile()[-1], 1.0 | units.RSun)
self.assertIsOfOrder(instance.particles[1].get_temperature_profile()[0], 1.0e7 | units.K)
self.assertIsOfOrder(instance.particles[1].get_pressure_profile()[0], 1.0e17 | units.barye)
t1, l1 = simulate_evolution_tracks(instance.particles[0], end_time=26.5|units.Gyr)
t2, l2 = simulate_evolution_tracks(instance.particles[1], end_time=26.5|units.Gyr)
instance.stop()
i1 = t1.argmax() # Maximum temperature ~ turnoff main sequence
i2 = t2.argmax()
self.assertAlmostRelativeEqual(t1[i1], t2[i2], 2)
self.assertAlmostRelativeEqual(l1[i1], l2[i2], 2)
def xtest9(self):
print "Test for changing the stellar structure model (not yet implemented)"
star = Particles(1)
star.mass = 1.0 | units.MSun
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(star)
instance.commit_particles()
instance.evolve_model()
density_profile = instance.particles[0].get_density_profile()
self.assertRaises(AmuseException, instance.particles[0].set_density_profile, density_profile[2:],
expected_message = "The length of the supplied vector (197) does not match the number of "
"mesh zones of the star (199).")
mass_factor = 1.1
instance.particles[0].set_density_profile(mass_factor*density_profile)
self.assertAlmostRelativeEqual(instance.particles[0].get_density_profile(), density_profile*mass_factor, places=10)
instance.particles.mass *= mass_factor
instance.evolve_model()
outer_radius = instance.particles[0].get_radius_profile()
inner_radius = outer_radius[:-1]
inner_radius.prepend(0|units.m)
delta_radius_cubed = (outer_radius**3 - inner_radius**3)
integrated_mass = (4./3.*pi*delta_radius_cubed*instance.particles[0].get_density_profile()).sum()
self.assertAlmostRelativeEqual(integrated_mass, star.mass*mass_factor, places = 3)
instance.stop()
del instance
def xtest13(self):
print "Test evolve_model optional arguments: end_time and keep_synchronous"
stars = Particles(3)
stars.mass = [1.0, 2.0, 3.0] | units.MSun
instance = EVtwin()
instance.particles.add_particles(stars)
self.assertAlmostEqual(instance.particles.age, [0.0, 0.0, 0.0] | units.yr)
self.assertAlmostEqual(instance.particles.time_step, [70465.105509, 6063.68785133, 1876.53255132] | units.yr, 3)
print "evolve_model without arguments: use shared timestep = 0.99*min(particles.time_step)"
instance.evolve_model()
self.assertAlmostEqual(instance.particles.age, 0.99*([1876.53255132,1876.53255132,1876.53255132] | units.yr), 3)
self.assertAlmostEqual(instance.particles.time_step, [70465.105509,6063.68785133,1876.53255132] | units.yr, 3)
self.assertAlmostEqual(instance.model_time, 0.99*1876.53255132 | units.yr, 3)
print "evolve_model with end_time: take timesteps, until end_time is reached exactly"
instance.evolve_model(15000 | units.yr)
self.assertAlmostEqual(instance.particles.age, [15000.0, 15000.0, 15000.0] | units.yr, 3)
self.assertAlmostEqual(instance.particles.time_step, [ 84558.1266108,7276.4254216,2251.83906159] | units.yr, 3)
self.assertAlmostEqual(instance.model_time, 15000.0 | units.yr, 3)
print "evolve_model with keep_synchronous: use non-shared timestep, particle ages will typically diverge"
instance.evolve_model(keep_synchronous = False)
self.assertAlmostEqual(instance.particles.age, (15000 | units.yr) + ([ 84558.1266108,7276.4254216,2251.83906159] | units.yr), 3)
self.assertAlmostRelativeEquals(instance.particles.time_step, [101469.751933,8731.71050591,2702.2068739] | units.yr, 1)
self.assertAlmostEqual(instance.model_time, 15000.0 | units.yr, 3) # Unchanged!
instance.stop()
def test5(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]
x = trees.BinaryTreesOnAParticleSet(particles, "child1", "child2")
roots = list(x.iter_roots())
self.assertEquals(len(roots), 1)
y = [(event, x.mass.value_in(units.kg)) for event, x in roots[0].iter_events()]
self.assertEquals(y,
[
('start', 0.0),
('start', 1.0),
('start', 3.0),
('end', 3.0),
('start', 4.0),
('end', 4.0),
('end', 1.0),
('start', 2.0),
('end', 2.0),
('end', 0.0)
]
)
def test5(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]
x = particles.as_binary_tree()
roots = list(x.iter_branches())
self.assertEquals(len(roots), 1)
binary = roots[0]
output = ''
for level, node in binary.iter_levels():
output += '..' * level
output += str(node.particle.mass.value_in(units.kg))
output += '\n'
print output
self.assertEquals(output, """0.0
..1.0
....3.0
....4.0
..2.0
""")
def test1(self):
particles = Particles(2)
particles.mass = [1.0, 1.0] | nbody_system.mass
particles.radius = [0.0001, 0.0001] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | nbody_system.speed
instance = bridge.CalculateFieldForParticles(particles=particles, gravity_constant=nbody_system.G)
zero = 0.0 | nbody_system.length
print instance.get_gravity_at_point([zero], [1.0] | nbody_system.length, [zero], [zero])
fx, fy, fz = instance.get_gravity_at_point([zero], [1.0] | nbody_system.length, [zero], [zero])
self.assertAlmostEqual(fx, [0.0] | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy, [0.0] | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz, [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])
fx0, fy0, fz0 = instance.get_gravity_at_point([zero], [x0], [zero], [zero])
fx1, fy1, fz1 = instance.get_gravity_at_point([zero], [x1], [zero], [zero])
self.assertAlmostEqual(fy0[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz0[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fy1[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fz1[0], 0.0 | nbody_system.acceleration, 6)
self.assertAlmostEqual(fx0, -1.0 * fx1, 5)
fx = (-1.0 / (x0 ** 2) + 1.0 / (x1 ** 2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0[0], 5)
self.assertAlmostEqual(potential0, potential1, 6)
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 test10(self):
p = Particles(2)
p[0].position = [1.0, 2.0, 3.0] | nbody_system.length
p[1].position = [4.0, 5.0, 6.0] | nbody_system.length
p[0].velocity = [7.0, 8.0, 10.0] | nbody_system.length / nbody_system.time
p[1].velocity = [11.0, 12.0, 13.0] | nbody_system.length / nbody_system.time
p.u = [3,4] | nbody_system.potential
p.rho = [5,6] | nbody_system.density
p.mass = [5,6] | nbody_system.mass
x = gadget.GadgetFileFormatProcessor(set = p)
file = BytesIO()
x.store_body(file)
input = BytesIO(file.getvalue())
positions = x.read_fortran_block_float_vectors(input)
self.assertEquals(positions[0] , [1.0, 2.0, 3.0])
self.assertEquals(positions[1] , [4.0, 5.0, 6.0])
velocities = x.read_fortran_block_float_vectors(input)
self.assertEquals(velocities[0] , [7.0, 8.0, 10.0])
self.assertEquals(velocities[1] , [11.0, 12.0, 13.0])
ids = x.read_fortran_block_ulongs(input)
self.assertEquals(ids[0], p[0].key)
self.assertEquals(ids[1], p[1].key)
masses = x.read_fortran_block_floats(input)
self.assertEquals(masses[0], 5)
self.assertEquals(masses[1], 6)
u = x.read_fortran_block_floats(input)
self.assertEquals(u[0], 3)
self.assertEquals(u[1], 4)
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 test58(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "test58"+self.store_version()+".h5")
if os.path.exists(output_file):
os.remove(output_file)
x = Particles(keys = (1,2))
x.mass = [1,2] | units.kg
y = Particles(keys = (11,12,13,14))
y.mass = [40,50,60,70] | units.kg
x.sub = None
x[0].sub = y[0:2]
y[0].sub = y[2:]
io.write_set_to_file(x, output_file,"amuse", version=self.store_version())
z = io.read_set_from_file(output_file,"amuse")
self.assertEqual(len(x), len(z))
self.assertEqual(len(x[0].sub), len(z[0].sub))
self.assertEqual(x[0].sub[0].sub.key, (13,14))
self.assertEqual(z[0].sub[0].sub.key, (13,14))
self.assertEqual(id(x[0].sub._original_set()), id(x[0].sub[0].sub._original_set()))
# no more subsets, could this be fixed, would be very nice to do so
# self.assertEqual(id(z[0].sub._original_set()), id(z[0].sub[0].sub._original_set()))
self.assertTrue(z[1].sub==x[1].sub==None)
os.remove(output_file)
def slowtest8(self):
print "Test for obtaining the stellar composition structure - evolved star"
stars = Particles(1)
stars.mass = 1.0 | units.MSun
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(stars)
instance.commit_particles()
instance.evolve_model(11.7 | units.Gyr)
self.assertTrue(instance.particles[0].age >= 11.7 | units.Gyr)
print instance.particles[0].stellar_type
#~ self.assertTrue(str(instance.particles[0].stellar_type) == "First Giant Branch")
number_of_zones = instance.particles.get_number_of_zones()[0]
number_of_species = instance.particles.get_number_of_species()[0]
composition = instance.particles[0].get_chemical_abundance_profiles()
species_names = instance.particles[0].get_names_of_species()
self.assertEquals(number_of_zones, 199)
self.assertEquals(number_of_species, 9)
self.assertEquals(len(species_names), number_of_species)
self.assertEquals(len(composition), number_of_species)
self.assertEquals(len(composition[0]), number_of_zones)
self.assertEquals(species_names, ['h1', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24', 'si28', 'fe56'])
self.assertAlmostRelativeEquals(composition[0, -1], 0.7 | units.none, 1)
self.assertAlmostRelativeEquals(composition[1, -1], 0.3 - instance.parameters.metallicity, 1)
self.assertAlmostRelativeEquals(composition[2:,-1].sum(), instance.parameters.metallicity, 1)
self.assertAlmostEquals(composition.sum(axis=0), [1.0]*number_of_zones | units.none)
self.assertAlmostEquals(composition[0, 0], 0.00 | units.none)
self.assertAlmostEquals(composition[1, 0], 1.00 - instance.parameters.metallicity, 3)
self.assertAlmostEquals(composition[2:,0].sum(), instance.parameters.metallicity, 3)
instance.stop()
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 = 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 test6(self):
print "Test for obtaining the stellar structure model"
stars = Particles(2)
stars.mass = [1.0, 10.0] | units.MSun
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertEquals(instance.particles.get_number_of_zones(), [199, 199])
self.assertEquals(len(instance.particles[0].get_radius_profile()), 199)
self.assertRaises(AmuseException, instance.particles.get_radius_profile,
expected_message = "Querying radius profiles of more than one particle at a time is not supported.")
self.assertEquals(len(instance.particles[1].get_density_profile()), 199)
self.assertIsOfOrder(instance.particles[0].get_radius_profile()[-1], 1.0 | units.RSun)
self.assertIsOfOrder(instance.particles[0].get_temperature_profile()[0], 1.0e7 | units.K)
self.assertIsOfOrder(instance.particles[0].get_temperature_profile()[-1], 5.0e3 | units.K)
radius1 = instance.particles[0].get_radius_profile()
radius2 = radius1[:-1]
radius2.prepend(0|units.m)
delta_radius_cubed = (radius1**3 - radius2**3)
total_mass = (4./3. * pi * instance.particles[0].get_density_profile() * delta_radius_cubed).sum()
self.assertAlmostRelativeEqual(total_mass, stars[0].mass, places = 1)
self.assertAlmostEquals(instance.particles[0].get_mu_profile()[:100], [0.62]*100 | units.amu, places=1)
instance.stop()
def test9(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "test9"+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
io.write_set_to_file(
p,
output_file,
"hdf5",
timestamp = 2 | units.Myr,
scale = 1 | units.kg,
version = self.store_version(),
close_file = True
)
loaded_particles = io.read_set_from_file(
output_file,
"hdf5",
version = self.store_version()
)
loaded_particles = self.get_version_in_store(loaded_particles)
a = loaded_particles.collection_attributes
self.assertAlmostRelativeEquals(a.timestamp, 2 | units.Myr)
self.assertAlmostRelativeEquals(a.scale, 1 | units.kg)
def test6(self):
print "Test whether a set of stars evolves synchronously..."
# Create an array of stars with a range in stellar mass
masses = [.5, 1., 2., 5., 10., 30.] | units.MSun
number_of_stars = len(masses)
stars = Particles(number_of_stars)
stars.mass = masses
# Initialize stellar evolution code
instance = SSE()
instance.commit_parameters()
instance.particles.add_particles(stars)
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
from_code_to_model.copy()
instance.evolve_model(end_time = 125 | units.Myr)
from_code_to_model.copy()
end_types = (
"deeply or fully convective low mass MS star",
"Main Sequence star",
"Main Sequence star",
"Carbon/Oxygen White Dwarf",
"Neutron Star",
"Black Hole",
)
for i in range(number_of_stars):
self.assertAlmostEquals(stars[i].age, 125.0 | units.Myr)
self.assertTrue(stars[i].mass <= masses[i])
self.assertEquals(str(stars[i].stellar_type), end_types[i])
instance.stop()
def test17(self):
print "evolve_one_step and evolve_for after particle removal and addition"
particles = Particles(10)
particles.mass = range(1, 11) | units.MSun
instance = SSE()
instance.particles.add_particles(particles)
self.assertAlmostEqual(instance.particles.age, 0.0 | units.yr)
time_steps = numpy.linspace(0.1, 1.0, num=10) | units.Myr
for i in range(10):
instance.particles[i].evolve_for(time_steps[i])
self.assertAlmostEqual(instance.particles.age, time_steps)
instance.particles.remove_particles(particles[[1, 4, 8]])
revived = instance.particles.add_particle(particles[4])
revived.evolve_for(numpy.pi | units.Myr)
for star in instance.particles:
star.evolve_for(star.age)
self.assertAlmostEqual(instance.particles.age[:-1], 2*time_steps[[0, 2,3, 5,6,7, 9]])
self.assertAlmostEqual(instance.particles.age[-1], 2*numpy.pi | units.Myr)
instance.particles.remove_particles(particles[[2, 5, 6]])
instance.particles.add_particles(particles[[8, 1]])
self.assertEqual(len(instance.particles), 7)
expected_ages = instance.particles.age + instance.particles.time_step
for star in instance.particles:
star.evolve_one_step()
self.assertAlmostEqual(instance.particles.age, expected_ages)
instance.stop()
def test12(self):
print "Testing adding and removing particles from stellar evolution code..."
particles = Particles(3)
particles.mass = 1.0 | units.MSun
instance = SSE()
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 test5(self):
print "Testing adding and removing particles from stellar evolution code..."
particles = Particles(3)
particles.mass = 0.3 | units.MSun
instance = EVtwin()#redirection="none")
instance.initialize_code()
instance.parameters.verbosity = True
instance.commit_parameters()
stars = instance.particles
self.assertEquals(len(stars), 0) # before creation
stars.add_particles(particles[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEquals(len(stars), 2) # before remove
self.assertAlmostEqual(stars.age, 1.0 | units.Myr)
stars.remove_particle(particles[0])
self.assertEquals(len(stars), 1)
self.assertEquals(instance.get_number_of_particles(), 1)
instance.evolve_model(2.0 | units.Myr)
self.assertAlmostEqual(stars[0].age, 2.0 | units.Myr)
stars.add_particles(particles[::2])
self.assertEquals(len(stars), 3) # it's back...
self.assertAlmostEqual(stars[0].age, 2.0 | units.Myr)
self.assertAlmostEqual(stars[1].age, 0.0 | units.Myr)
self.assertAlmostEqual(stars[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(stars.age, [3.0, 1.0, 1.0] | units.Myr)
instance.evolve_model(4.0 | units.Myr)
self.assertAlmostEqual(stars.age, [4.0, 2.0, 2.0] | units.Myr)
instance.stop()
def test_supernova_stopping_condition_with_multiple_stars_of_equal_mass(
self):
""" Test supernova stopping condition with multiple stars of equal mass """
instance = self.new_instance_of_an_optional_code(SeBa)
instance.stopping_conditions.supernova_detection.enable()
stars = Particles(3)
stars[0].mass = 10.0 | units.MSun
stars[1].mass = 10.0 | units.MSun
stars[2].mass = 0.5 | units.MSun
instance.particles.add_particles(stars)
instance.evolve_model(30 | units.Myr)
self.assertEqual(
instance.stopping_conditions.supernova_detection.is_set(), True)
self.assertEqual(
len(instance.stopping_conditions.supernova_detection.particles(0)),
2)
self.assertEqual(
instance.stopping_conditions.supernova_detection.particles(0)
[0].key, instance.particles[0].key)
self.assertEqual(
instance.stopping_conditions.supernova_detection.particles(0)
[1].key, instance.particles[1].key)
self.assertAlmostRelativeEqual(instance.particles[0].age,
27.35866 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age,
27.35866 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[2].age,
27.35866 | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass,
1.2476 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass,
1.2476 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[2].mass,
0.5 | units.MSun, 4)
# self.assertAlmostRelativeEqual(instance.particles[0].natal_kick_velocity, [0,0,0] | units.kms, 4)
# self.assertAlmostRelativeEqual(instance.particles[1].natal_kick_velocity, [0,0,0] | units.kms, 4)
instance.evolve_model(30 | units.Myr)
self.assertEqual(
instance.stopping_conditions.supernova_detection.is_set(), False)
self.assertAlmostRelativeEqual(instance.particles[0].age,
30. | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[1].age,
30. | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[2].age,
30. | units.Myr, 4)
self.assertAlmostRelativeEqual(instance.particles[0].mass,
1.2476 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[1].mass,
1.2476 | units.MSun, 4)
self.assertAlmostRelativeEqual(instance.particles[2].mass,
0.5 | units.MSun, 4)
def result(self):
masses, positions, velocities, internal_energies = self.new_model()
result = Particles(self.actual_number_of_particles)
result.mass = nbody_system.mass.new_quantity(masses)
result.position = nbody_system.length.new_quantity(positions)
result.velocity = nbody_system.speed.new_quantity(velocities)
result.u = nbody_system.specific_energy.new_quantity(internal_energies)
result.position -= result.center_of_mass()
if self.do_scale:
scale_factor = (result.potential_energy(G=nbody_system.G)) / (-0.5 | nbody_system.energy)
result.position *= scale_factor
if not self.convert_nbody is None:
result = ParticlesWithUnitsConverted(result, self.convert_nbody.as_converter_from_si_to_generic())
result = result.copy()
return result
def test1(self):
sse = SSE()
sse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | units.MSun
star.radius = 0.0 | units.RSun
sse.particles.add_particles(stars)
from_sse_to_model = sse.particles.new_channel_to(stars)
from_sse_to_model.copy()
previous_type = star.stellar_type
results = []
t0 = 0 | units.Myr
current_time = t0
while current_time < (125 | units.Myr):
sse.update_time_steps()
current_time = current_time + sse.particles[0].time_step
sse.evolve_model(current_time)
from_sse_to_model.copy()
if not star.stellar_type == previous_type:
results.append((star.age, star.mass, star.stellar_type))
previous_type = star.stellar_type
self.assertEqual(len(results), 6)
times = (104.0 | units.Myr, 104.4 | units.Myr, 104.7 | units.Myr,
120.1 | units.Myr, 120.9 | units.Myr, 121.5 | units.Myr)
for result, expected in zip(results, times):
self.assertAlmostEqual(result[0].value_in(units.Myr),
expected.value_in(units.Myr), 1)
masses = (5.000 | units.MSun, 5.000 | units.MSun, 4.998 | units.MSun,
4.932 | units.MSun, 4.895 | units.MSun, 0.997 | units.MSun)
for result, expected in zip(results, masses):
self.assertAlmostEqual(result[1].value_in(units.MSun),
expected.value_in(units.MSun), 3)
types = (
"Hertzsprung Gap",
"First Giant Branch",
"Core Helium Burning",
"First Asymptotic Giant Branch",
"Second Asymptotic Giant Branch",
"Carbon/Oxygen White Dwarf",
)
for result, expected in zip(results, types):
self.assertEquals(str(result[2]), expected)
sse.stop()
class GravityCodeForTesting(object):
def __init__(self):
self.particles = Particles()
self.model_time = quantities.zero
def evolve_model(self, t_end):
self.particles.position += self.particles.velocity * (t_end -
self.model_time)
self.model_time = t_end
@property
def potential_energy(self):
G = nbody_system.G if self.particles.x.unit == nbody_system.length else constants.G
return self.particles.potential_energy(G=G)
@property
def kinetic_energy(self):
return self.particles.kinetic_energy()
def get_moons_for_planet(planet, delta_JD=0. | units.day):
"""
The Earth's moon
as for JD = 2457099.500000000 = A.D. 2015-Mar-18 00:00:00.0000 (CT)
https://ssd.jpl.nasa.gov/?sat_elem
"""
data = numpy.array([tuple(entry) for entry in _lunar_data],
dtype=[('planet_name', 'S10'), ('name', 'S10'),
('mass', '<f8'), ('radius', '<f8'),
('semimajor_axis', '<f8'),
('eccentricity', '<f8'),
('argument_of_peri', '<f8'),
('mean_anomaly', '<f8'), ('inclination', '<f8'),
('longitude_oan', '<f8')])
moon_data = data[data['planet_name'] == planet.name]
print "Planet=", planet.name, "moon=", moon_data["name"]
moons = Particles()
if len(moon_data["name"]):
print len(moon_data["name"])
for moon in moon_data:
#print moon
r, v = get_position(planet.mass,
moon["mass"] * 1.e+16 | units.kg,
moon["eccentricity"],
moon["semimajor_axis"] | units.km,
numpy.deg2rad(moon["mean_anomaly"]),
numpy.deg2rad(moon["inclination"]),
numpy.deg2rad(moon["longitude_oan"]),
numpy.deg2rad(moon["argument_of_peri"]),
delta_t=delta_JD)
single_moon = Particle()
single_moon.type = "moon"
single_moon.name = moon["name"]
single_moon.mass = moon["mass"] * 1.e+16 | units.kg
single_moon.hostname = moon["planet_name"]
single_moon.radius = moon["radius"] | units.km
single_moon.position = r
single_moon.position += planet.position
single_moon.velocity = v
single_moon.velocity += planet.velocity
moons.add_particle(single_moon)
return moons
def new_particles_with_internal_structure_from_models(self):
def get_internal_structure(set, particle=None):
return self.models[(set.key == particle.key).nonzero()[0]]
result = Particles(len(self.models))
result.add_function_attribute("get_internal_structure", None, get_internal_structure)
result.mass = [model.dmass.sum().as_quantity_in(self.mass_unit) for model in self.models]
result.radius = [model.radius[-1].as_quantity_in(self.radius_unit) for model in self.models]
result.position = (self.original_center_of_mass + self.stars_after_encounter.position).as_quantity_in(self.position_unit)
result.velocity = (self.original_center_of_mass_velocity + self.stars_after_encounter.velocity).as_quantity_in(self.velocity_unit)
return result
def merge_two_stars(primary, secondary):
"Merge two colliding stars into one new one"
colliders = Particles()
colliders.add_particle(primary)
colliders.add_particle(secondary)
new_particle = Particle()
new_particle.mass = colliders.mass.sum()
new_particle.position = colliders.center_of_mass()
new_particle.velocity = colliders.center_of_mass_velocity()
return new_particle
def mechanical_feedback(self, time_step):
L_mech_new = self.star_particles.mechanical_luminosity
self.star_particles.E_mech += time_step * 0.5 * (
self.star_particles.L_mech + L_mech_new)
self.star_particles.L_mech = L_mech_new
self.star_particles.dmass = self.star_particles.previous_mass - self.star_particles.mass
self.star_particles.n_feedback_particles = numpy.array(
self.star_particles.dmass /
self.feedback_gas_particle_mass).astype(int)
losers = self.star_particles.select_array(lambda x: x > 0,
["n_feedback_particles"])
if self.verbose:
print "GravityHydroStellar: Number of particles providing mechanical feedback during this step:", len(
losers)
if len(losers) == 0:
return
channel = self.gravity.particles.new_channel_to(losers)
channel.copy_attributes(["x", "y", "z", "vx", "vy", "vz"])
number_of_new_particles = losers.n_feedback_particles.sum()
new_sph_all = Particles(number_of_new_particles)
new_sph_all.mass = self.feedback_gas_particle_mass
new_sph_all.h_smooth = 0.0 | units.parsec
offsets = self.draw_random_position_offsets(number_of_new_particles)
i = 0
for loser in losers:
i_next = i + loser.n_feedback_particles
new = new_sph_all[i:i_next]
new.position = loser.position + offsets[i:i_next]
new.velocity = loser.velocity
new.u = self.feedback_efficiency * (
loser.E_mech - loser.E_mech_last_feedback) / loser.dmass
i = i_next
losers.previous_mass -= self.feedback_gas_particle_mass * losers.n_feedback_particles
losers.E_mech_last_feedback = losers.E_mech
channel = losers.new_channel_to(self.gravity.particles)
channel.copy_attribute("previous_mass", "mass")
if self.verbose:
print "GravityHydroStellar: New SPH particles:"
print new_sph_all
self.hydro.gas_particles.add_particles(new_sph_all)
self.total_feedback_energy += (new_sph_all.mass * new_sph_all.u).sum()
def new_colliders(self):
colliders = Particles(2)
colliders.mass = [5, 2] | units.MSun
colliders.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]] | units.RSun
colliders.velocity = [[0.0, 0.0, 0.0], [0.0, 2000.0, 0.0]
] | units.km / units.s
colliders.move_to_center()
return colliders
def set_up_inner_binary(inclination):
semimajor_axis = triple_parameters["a_in"]
masses = triple_parameters["masses_in"]
print " Initializing inner binary"
stars = Particles(2)
stars.mass = masses
stars.position = [0.0, 0.0, 0.0] | units.AU
stars.velocity = [0.0, 0.0, 0.0] | units.km / units.s
stars[0].y = semimajor_axis
stars[0].vx = -math.cos(inclination) * get_relative_velocity_at_apastron(
stars.total_mass(), semimajor_axis, 0)
stars[0].vz = math.sin(inclination) * get_relative_velocity_at_apastron(
stars.total_mass(), semimajor_axis, 0)
stars.move_to_center()
return stars
def new_sun_earth_system(self):
particles = Particles(2)
particles.mass = [1.0, 3.0037e-6] | units.MSun
particles.radius = 1.0 | units.RSun
particles.position = [[0.0, 0.0, 0.0], [1.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 * particles.total_mass() / (1.0 | units.AU)).sqrt()
return particles
def test4(self):
particles = Particles(10)
particles.mass = list(range(10)) | units.kg
particles[0].child1 = particles[2]
particles[0].child2 = particles[1]
particles[1].child1 = particles[4]
particles[1].child2 = particles[3]
particles[2].child1 = particles[6]
particles[2].child2 = particles[5]
tree = particles.as_binary_tree()
masses = [] | units.kg
stack = list(reversed(tree.get_children()))
while stack:
x = stack.pop()
masses.append(x.particle.mass)
stack.extend(reversed(x.get_children()))
self.assertEqual(masses, [0, 2, 6, 5, 1, 4, 3, 7, 8, 9] | units.kg)
def convert_stars(self, particles, stellar_evolution_code):
n_particles = self.divide_number_of_particles(particles)
se_colliders = particles.get_intersecting_subset_in(stellar_evolution_code.particles)
if self.verbose:
print("Converting stars of {0} to SPH models of {1} particles, respectively.".format(particles.mass, n_particles))
sph_models = (
self.relax(convert_stellar_model_to_SPH(se_colliders[0], n_particles[0], **self.star_to_sph_arguments)),
self.relax(convert_stellar_model_to_SPH(se_colliders[1], n_particles[1], **self.star_to_sph_arguments))
)
gas_particles = Particles()
for particle, sph_model in zip(particles, sph_models):
sph_model.position += particle.position
sph_model.velocity += particle.velocity
gas_particles.add_particles(sph_model)
if self.verbose:
print("Converting stars to SPH particles done")
if self.debug:
print(gas_particles)
return gas_particles
def test30(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "test30"+self.store_version()+".hdf5")
if os.path.exists(output_file):
os.remove(output_file)
particles = Particles(10)
particles.mass = 10 | units.kg
io.write_set_to_file(particles,output_file, format='amuse', version = self.store_version())
output = io.read_set_from_file(output_file, format='amuse', allow_writing = True)
output.new_attribute= 2 * output.mass
self.assertEquals(output.new_attribute, 2 * output.mass)
output = output.iter_history().next()
output.new_attribute= 2 * output.mass
self.assertEquals(output.new_attribute, 2 * output.mass)
def planet_from_orbital_elements(mass, sma, ecc, true_anom, inc, long_asc_node,
arg_peri):
"""
returns one particle (a planet) w/ coordinates in 'Center of Mass' frame of the binary
This is not what you would expect from the typical binary_from_... function.
"""
two_bodies = kepler_binary_from_orbital_elements(mass, 0.0 * mass, sma,
ecc, true_anom, inc,
long_asc_node, arg_peri)
# Move to 'Binary' Frame
two_bodies.position -= two_bodies[0].position
two_bodies.velocity -= two_bodies[0].velocity
planet = Particles(0)
planet.add_particle(two_bodies[1])
return planet
def test14(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "test14"+self.store_version()+".hdf5")
if os.path.exists(output_file):
os.remove(output_file)
stars = Particles(2)
stars.x = 1.0 | units.km
stars.md = [[[1,3],[2,4],[3,5]],[[4,6],[5,7],[6,8]]]
io.write_set_to_file(stars, output_file, "hdf5", version = self.store_version())
loaded = io.read_set_from_file(output_file, "hdf5", version = self.store_version())
self.assertEquals(loaded[0].md, [[1,3],[2,4],[3,5]])
self.assertEquals(loaded[1].md, [[4,6],[5,7],[6,8]])
self.assertEquals(loaded.md[0], [[1,3],[2,4],[3,5]])
self.assertEquals(loaded.md[1], [[4,6],[5,7],[6,8]])
def test8(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path,
"test8" + 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 = numpy.asarray([x * 2.0 for x in range(number_of_particles)])
instance.store(p.savepoint(1 | nbody_system.time))
instance.close()
instance = self.store_factory()(output_file)
loaded_particles = instance.load()
self.assertAlmostRelativeEquals(p.mass[1], 2.0)
instance.close()
def test1(self):
particles = Particles(10)
particles.mass = list(range(10)) | units.kg
particles[0].child1 = particles[1]
particles[0].child2 = particles[2]
self.assertEqual(particles[0].mass, 0 | units.kg)
self.assertEqual(particles[0].child1.mass, 1 | units.kg)
self.assertEqual(particles[1].child1, None)
tree = particles.as_binary_tree()
self.assertFalse(tree.is_leaf())
self.assertEqual(len(list(tree.iter_children())), 8)
self.assertEqual(len(list(tree.iter_branches())), 1)
self.assertEqual(len(list(tree.iter_leafs())), 7)
branches = list(tree.iter_branches())
self.assertEqual(len(list(branches[0].iter_children())), 2)
self.assertEqual(len(list(branches[0].iter_branches())), 0)
self.assertEqual(len(list(branches[0].iter_leafs())), 2)
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:
print(star)
stellar_evolution = MOSSE()
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 test10(self):
stellar_evolution = SSE()
stellar_evolution.commit_parameters()
stars = Particles(10)
stars.mass = 1.0 | units.MSun
stellar_evolution.particles.add_particles(stars)
self.assertEqual(
stellar_evolution.particles._factory_for_new_collection(),
Particles)
filename = os.path.join(get_path_to_results(), "test.h5")
if os.path.exists(filename):
os.remove(filename)
io.write_set_to_file(stellar_evolution.particles, filename, 'hdf5')
stored_stars = io.read_set_from_file(filename, 'hdf5')
self.assertEqual(len(stars), len(stored_stars))
self.assertAlmostRelativeEquals(stars.mass, stored_stars.mass)
def setup_stellar_evolution_model():
out_pickle_file = os.path.join(get_path_to_results(),
"super_giant_stellar_structure.pkl")
if os.path.exists(out_pickle_file):
return out_pickle_file
print("Creating initial conditions from a MESA stellar evolution model...")
stellar_evolution = MESA(redirection="none")
stars = Particles(1)
stars.mass = 10.0 | units.MSun
stellar_evolution.particles.add_particles(stars)
while stellar_evolution.particles[
0].stellar_type <= 12 | units.stellar_type:
stellar_evolution.evolve_model()
pickle_stellar_model(stellar_evolution.particles[0], out_pickle_file)
stellar_evolution.stop()
return out_pickle_file
def test5(self):
print("Testing stellar collision...")
instance = MOBSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 130.0 | units.MSun
stars[1].mass = 50 | units.MSun
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
orbital_period = 300.0 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass , stars[1].mass)
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.99
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_mobse_to_model = instance.particles.new_channel_to(stars)
from_mobse_to_model.copy()
from_mobse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_mobse_to_model_binaries.copy()
instance.evolve_model(170 | units.Myr)
from_mobse_to_model.copy()
from_mobse_to_model_binaries.copy()
print(binaries)
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 180.00, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.000, 3)
self.assertEqual(str(binary.child1.stellar_type), "Main Sequence star")
self.assertEqual(str(binary.child2.stellar_type), "Massless Supernova")
instance.stop()
def handle_collision(self, coll_time, corr_time, coll_set):
print("collision:", len(coll_set))
subsystems = self.particles.compound_particles()
collsubset = self.particles[0:0]
collsubsystems = Particles()
for p in coll_set:
p = p.as_particle_in_set(self.particles)
collsubset += p
if self.subcodes.has_key(p):
code = self.subcodes[p]
code.evolve_model(coll_time)
print(coll_time - code.model_time) / self.timestep
if p.subsystem is not None:
collsubsystems.add_particle(p)
print("corr", coll_time.in_(units.yr),
(coll_time - corr_time) / self.timestep)
self.correction_kicks(collsubset, collsubsystems,
coll_time - corr_time)
newparts = HierarchicalParticles(Particles())
to_remove = Particles()
for p in coll_set:
p = p.as_particle_in_set(self.particles)
if self.subcodes.has_key(p):
code = self.subcodes.pop(p)
parts = code.particles.copy()
parts.position += p.position
parts.velocity += p.velocity
newparts.add_particles(parts)
del code
else:
np = newparts.add_particle(p)
np.radius = p.sub_worker_radius
to_remove.add_particle(p)
self.particles.remove_particles(to_remove)
newcode = self.subcode_factory(newparts)
newcode.parameters.begin_time = coll_time
newcode.particles.add_particles(newparts)
newparent = self.particles.add_subsystem(newcode.particles)
self.set_parent_particle_radius(newparent)
newparent.sub_worker_radius = 0. * newparent.radius
print("radius:", newparent.radius.in_(units.parsec),
newparent.sub_worker_radius.in_(units.parsec))
self.subcodes[newparent] = newcode
return newparent
def test4(self):
print("Quick testing standard MOBSE example 2...")
instance = MOBSE()
instance.parameters.common_envelope_efficiency = 3.0
instance.parameters.common_envelope_binding_energy_factor= 0.5
instance.parameters.Eddington_mass_transfer_limit_factor = 10.0
instance.commit_parameters()
stars = Particles(2)
stars[0].mass = 7.816 | units.MSun
stars[1].mass = 4.387 | units.MSun
instance.particles.add_particles(stars)
binaries = Particles(1)
binary = binaries[0]
orbital_period = 1964.18453 | units.day
semi_major_axis = instance.orbital_period_to_semi_major_axis(orbital_period, stars[0].mass , stars[1].mass)
binary.semi_major_axis = semi_major_axis
binary.eccentricity = 0.0
binary.child1 = stars[0]
binary.child2 = stars[1]
instance.binaries.add_particles(binaries)
from_mobse_to_model = instance.particles.new_channel_to(stars)
from_mobse_to_model.copy()
from_mobse_to_model_binaries = instance.binaries.new_channel_to(binaries)
from_mobse_to_model_binaries.copy()
instance.evolve_model(170 | units.Myr)
from_mobse_to_model.copy()
from_mobse_to_model_binaries.copy()
self.assertAlmostEqual(binary.child1.mass.value_in(units.MSun), 1.26079, 3)
self.assertAlmostEqual(binary.child2.mass.value_in(units.MSun), 0.76080, 3)
self.assertEqual(str(binary.child1.stellar_type), "Neutron Star")
self.assertEqual(str(binary.child2.stellar_type), "Carbon/Oxygen White Dwarf")
instance.stop()
def test19(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path,
"test19" + self.store_version() + ".hdf5")
if os.path.exists(output_file):
os.remove(output_file)
stars = Particles(2)
stars[0].x = 1.0 | units.km
stars[1].x = 2.0 | units.km
binaries = Particles(1)
binaries[0].y = 1.0 | units.km
binaries[0].child1 = stars[0]
binaries[0].child2 = stars[1]
stars[0].parent = binaries[0]
stars[1].parent = binaries[0]
self.assertEqual(binaries[0].child1, stars[0])
self.assertEqual(binaries[0].child2, stars[1])
self.assertEqual(binaries[0].child1.parent, binaries[0])
self.assertEqual(binaries[0].child2.parent, binaries[0])
io.write_set_to_file([binaries, stars],
output_file,
"hdf5",
names=['binaries', 'children'],
version=self.store_version())
loader_binaries, loaded_stars = io.read_set_from_file(
output_file,
"hdf5",
names=['binaries', 'children'],
version=self.store_version())
self.assertEqual(loader_binaries[0].child1.key, stars[0].key)
self.assertEqual(loader_binaries[0].child2.key, stars[1].key)
self.assertEqual(loader_binaries[0].child1, loaded_stars[0])
self.assertEqual(loader_binaries[0].child2, loaded_stars[1])
self.assertEqual(loader_binaries[0].child1.parent, loader_binaries[0])
self.assertEqual(loader_binaries[0].child2.parent, loader_binaries[0])
def new_system(star_mass=1 | units.MSun,
star_radius=1 | units.RSun,
disk_minumum_radius=0.05 | units.AU,
disk_maximum_radius=10 | units.AU,
disk_mass=20 | MEarth,
accurancy=0.0001,
planet_density=3 | units.g / units.cm**3,
rng=None,
kepler=None):
central_particle = Particle()
central_particle.mass = star_mass
central_particle.position = (0, 0, 0) | units.AU
central_particle.velocity = (0, 0, 0) | units.kms
central_particle.radius = star_radius
if rng is None:
rng = numpy.random
converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
if kepler is None:
kepler = Kepler(converter)
kepler.initialize_code()
m, r, f = new_planet_distribution(disk_minumum_radius, disk_maximum_radius,
disk_mass, accurancy)
planets = make_planets(central_particle,
m,
r,
density=planet_density,
phi=0,
theta=None,
kepler=kepler,
rng=rng)
central_particle.planets = planets
kepler.stop()
p = Particles()
p.add_particle(central_particle)
return p
def __init__(self, softening_mode="shared"):
self.particles = Particles()
if softening_mode == "individual":
self.softening_mode = "individual"
self._softening_lengths_squared = self._softening_lengths_squared_individual
self._softening_lengths = self._softening_lengths_individual
else:
self.softening_mode = "shared"
self._softening_lengths_squared = self._softening_lengths_squared_shared
self._softening_lengths = self._softening_lengths_shared
epsilon_squared_parameter = parameters.ModuleMethodParameterDefinition(
"get_epsilon_squared",
"set_epsilon_squared",
"epsilon_squared",
"gravitational softening length squared",
default_value = 0.0 | nbody_system.length**2,
must_set_before_get = False
)
self.parameters = parameters.new_parameters_instance_with_docs([epsilon_squared_parameter], self)
self.epsilon_squared = 0.0 | nbody_system.length**2
def test2(self):
print "Testing ParallelStellarEvolution particles"
instance = ParallelStellarEvolution(self.code_factory,
number_of_workers=2,
**default_options)
instance.initialize_code()
instance.commit_parameters()
particles = Particles(5)
particles.mass = range(1, 1 + len(particles)) | units.MSun
incode = instance.particles.add_particles(particles)
instance.commit_particles()
self.assertAlmostEqual(incode.mass,
range(1, 1 + len(particles)) | units.MSun)
print "Note that the order of instance.particles is different from the",
print "original particle order, since particles are distributed over 2 processes"
self.assertAlmostEqual(instance.particles.mass,
[1, 3, 5, 2, 4] | units.MSun)
instance.stop()
def test22(self):
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "test22"+self.store_version()+".hdf5")
if os.path.exists(output_file):
os.remove(output_file)
stars = Particles(2)
stars.x = 1.0 | units.km
overlay = ParticlesOverlay(stars)
overlay.y = 2.0 | units.km
io.write_set_to_file(overlay, output_file, "hdf5", version = self.store_version())
loaded = io.read_set_from_file(output_file, "hdf5", close_file = True, version = self.store_version())
self.assertEquals(loaded[0].x, 1.0 | units.km)
self.assertEquals(loaded[1].y, 2.0 | units.km)
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
