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 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 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 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 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 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.assertEqual(str(result[2]), expected)
sse.stop()
def test9(self):
print "Test: large number of particles"
stellar_evolution = SSE(max_message_length=500)
stellar_evolution.commit_parameters()
number_of_particles = 10000
print "Has been tested with up to a million particles!"
print "Now using ", number_of_particles, "particles only, for speed."
stars = Particles(number_of_particles)
stars.mass = 1.0 | units.MSun
stellar_evolution.particles.add_particles(stars)
self.assertEqual(len(stellar_evolution.particles), number_of_particles)
stellar_evolution.stop()
def test9(self):
print("Test: large number of particles")
stellar_evolution = SSE(max_message_length=500)
stellar_evolution.commit_parameters()
number_of_particles = 10000
print("Has been tested with up to a million particles!")
print("Now using ", number_of_particles, "particles only, for speed.")
stars = Particles(number_of_particles)
stars.mass = 1.0 | units.MSun
stellar_evolution.particles.add_particles(stars)
self.assertEqual(len(stellar_evolution.particles), number_of_particles)
stellar_evolution.stop()
def planetplot():
sun, planets = new_solar_system_for_mercury()
initial = 12.2138 | units.Gyr
final = 12.3300 | units.Gyr
step = 10000.0 | units.yr
timerange = VectorQuantity.arange(initial, final, step)
gd = MercuryWayWard()
gd.initialize_code()
# gd.stopping_conditions.timeout_detection.disable()
gd.central_particle.add_particles(sun)
gd.orbiters.add_particles(planets)
gd.commit_particles()
se = SSE()
# se.initialize_code()
se.commit_parameters()
se.particles.add_particles(sun)
se.commit_particles()
channelp = gd.orbiters.new_channel_to(planets)
channels = se.particles.new_channel_to(sun)
for time in timerange:
err = gd.evolve_model(time-initial)
channelp.copy()
# planets.savepoint(time)
err = se.evolve_model(time)
channels.copy()
gd.central_particle.mass = sun.mass
print(
sun[0].mass.value_in(units.MSun),
time.value_in(units.Myr),
planets[4].x.value_in(units.AU),
planets[4].y.value_in(units.AU),
planets[4].z.value_in(units.AU)
)
gd.stop()
se.stop()
for planet in planets:
t, x = planet.get_timeline_of_attribute_as_vector("x")
t, y = planet.get_timeline_of_attribute_as_vector("y")
plot(x, y, '.')
native_plot.gca().set_aspect('equal')
native_plot.show()
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 test2(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)
sse.evolve_model(120.1 | units.Myr)
self.assertAlmostEqual(sse.particles[0].mass.value_in(units.MSun), 4.932, 3)
self.assertAlmostEqual(sse.particles[0].temperature.value_in(units.K), 4221., 0)
sse.stop()
def test2(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)
sse.evolve_model(120.1 | units.Myr)
self.assertAlmostEqual(sse.particles[0].mass.value_in(units.MSun), 4.932, 3)
self.assertAlmostEqual(sse.particles[0].temperature.value_in(units.K), 4221., 0)
sse.stop()
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 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.assertEquals(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.assertEquals(len(stars), len(stored_stars))
self.assertAlmostRelativeEquals(stars.mass, stored_stars.mass)
def planetplot():
sun, planets = new_solar_system_for_mercury()
initial = 12.2138 | units.Gyr
final = 12.3300 | units.Gyr
step = 10000.0 | units.yr
timerange = VectorQuantity.arange(initial, final, step)
gd = MercuryWayWard()
gd.initialize_code()
# gd.stopping_conditions.timeout_detection.disable()
gd.central_particle.add_particles(sun)
gd.orbiters.add_particles(planets)
gd.commit_particles()
se = SSE()
# se.initialize_code()
se.commit_parameters()
se.particles.add_particles(sun)
se.commit_particles()
channelp = gd.orbiters.new_channel_to(planets)
channels = se.particles.new_channel_to(sun)
for time in timerange:
err = gd.evolve_model(time - initial)
channelp.copy()
# planets.savepoint(time)
err = se.evolve_model(time)
channels.copy()
gd.central_particle.mass = sun.mass
print(
(sun[0].mass.value_in(units.MSun), time.value_in(units.Myr),
planets[4].x.value_in(units.AU), planets[4].y.value_in(units.AU),
planets[4].z.value_in(units.AU)))
gd.stop()
se.stop()
for planet in planets:
t, x = planet.get_timeline_of_attribute_as_vector("x")
t, y = planet.get_timeline_of_attribute_as_vector("y")
plot(x, y, '.')
native_plot.gca().set_aspect('equal')
native_plot.show()
def test8(self):
instance = SSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.stop()
instance = SSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
instance.parameters.set_defaults()
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
instance.stop()
def test8(self):
instance = SSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, myvalue)
instance.stop()
instance = SSE()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
myvalue = 0.7
instance.parameters.reimers_mass_loss_coefficient = myvalue
instance.parameters.set_defaults()
instance.commit_parameters()
self.assertEqual(instance.parameters.reimers_mass_loss_coefficient, 0.5)
instance.stop()
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 = 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 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 = 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.assertEquals(stars[0].initial_mass, stars[1].initial_mass)
self.assertEquals(stars[0].luminosity, stars[1].luminosity)
self.assertEquals(stars[0].age, stars[1].age)
print "Solved: SSE_muse_interface.f sets initial_mass to mass when necessary."
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.assertEqual(len(instance.particles), 0) # before creation
instance.particles.add_particles(particles[:-1])
instance.commit_particles()
instance.evolve_model(1.0 | units.Myr)
self.assertEqual(len(instance.particles), 2) # before remove
self.assertAlmostEqual(instance.particles.age, 1.0 | units.Myr)
instance.particles.remove_particle(particles[0])
self.assertEqual(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.assertEqual(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 test3(self):
sse = SSE()
sse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | 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 = sse.particles.stellar_type
results = []
sse.evolve_model(121.5 | units.Myr)
channel.copy_attributes(sse.particles.get_attribute_names_defined_in_store())
self.assertAlmostEqual(star.mass.value_in(units.MSun), 0.997, 3)
sse.stop()
def test3(self):
sse = SSE()
sse.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5 | 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 = sse.particles.stellar_type
results = []
sse.evolve_model(121.5 | units.Myr)
channel.copy_attributes(sse.particles.get_attribute_names_defined_in_store())
self.assertAlmostEqual(star.mass.value_in(units.MSun), 0.997, 3)
sse.stop()
dest="x_imf",
type="float",
default=-2.35,
help="Slope of the IMF. [-2.35]")
result.add_option("-v",
dest="verbose",
action="store_true",
default=False,
help="verbose output [True]")
o, arguments = result.parse_args()
t_end = o.t_end | units.Myr
dt = o.dt | units.Myr
stellar_evolution = SSE()
stellar_evolution.commit_parameters()
stars = Particles(o.N)
Mmin = o.Mmin | units.MSun
Mmax = o.Mmax | units.MSun
if o.verbose:
print("#Selected parameters: ")
print("#\tN=", o.N)
print("#\tIMF=", o.Mmin, "MSun", o.Mmax, "MSun", o.x_imf)
print("#\t t [Myr] \t <m> [MSun] \t\t d<m>/dt [MSun/Myr]")
stars.mass = new_salpeter_mass_distribution(o.N,
mass_min=Mmin,
mass_max=Mmax,
alpha=o.x_imf)
help="number of stars to calculate <m>. [10]")
result.add_option("-m", dest="Mmin", type="float", default=0.15,
help="Minimal mass of the IMF in MSun. [0.15MSun]")
result.add_option("-M", dest="Mmax", type="float", default=100,
help="Maximal mass of the IMF in MSun. [100MSun]")
result.add_option("-x", dest="x_imf", type="float", default=-2.35,
help="Slope of the IMF. [-2.35]")
result.add_option("-v", dest="verbose", action="store_true", default=False,
help="verbose output [True]")
o, arguments = result.parse_args()
t_end = o.t_end | units.Myr
dt = o.dt | units.Myr
stellar_evolution = SSE()
stellar_evolution.commit_parameters()
stars = Particles(o.N)
Mmin = o.Mmin | units.MSun
Mmax = o.Mmax | units.MSun
if o.verbose:
print("#Selected parameters: ")
print("#\tN=", o.N)
print("#\tIMF=", o.Mmin, "MSun", o.Mmax, "MSun", o.x_imf)
print("#\t t [Myr] \t <m> [MSun] \t\t d<m>/dt [MSun/Myr]")
stars.mass = new_salpeter_mass_distribution(
o.N, mass_min=Mmin, mass_max=Mmax, alpha=o.x_imf)
stars = stellar_evolution.particles.add_particles(stars)
stellar_evolution.commit_particles()
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()
