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 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 test11(self):
print "Test for importing new stellar models"
instance = EVtwin()
#~ instance.parameters.import_model_entropy_force = 1.0
#~ instance.parameters.import_model_entropy_accuracy = 1.0e-1
instance.parameters.verbosity = True
instance.particles.add_particles(Particles(mass = [0.8] | units.MSun))
instance.evolve_model()
instance.new_particle_from_model(instance.particles[0].get_internal_structure())
# The above line is equivalent with:
#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)
instance.evolve_model(keep_synchronous = False)
self.assertAlmostRelativeEqual(
instance.particles[0].temperature, instance.particles[1].temperature, 2)
self.assertAlmostRelativeEqual(
instance.particles[0].luminosity, instance.particles[1].luminosity, 2)
instance.stop()
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 slowtest5(self):
print "Test convert_SPH_to_stellar_model result in EVtwin"
stellar_evolution = EVtwin()
stellar_evolution.parameters.verbosity = True
stellar_evolution.particles.add_particle(
Particle(mass=1.0 | units.MSun)) # reference particle
stellar_evolution.evolve_model(100.0 | units.Myr)
model = convert_SPH_to_stellar_model(
self.new_particles()) # model is from center to surface
stellar_evolution.new_particle_from_model(model, 0.0 | units.Myr)
print stellar_evolution.particles
self.assertAlmostEqual(stellar_evolution.particles.age,
[100.0, 0.0] | units.Myr, 1)
stellar_evolution.evolve_model(200.0 | units.Myr)
print stellar_evolution.particles
self.assertAlmostEqual(stellar_evolution.particles.age,
[200.0, 100.0] | units.Myr, 1)
self.assertAlmostRelativeEqual(
stellar_evolution.particles[0].temperature,
stellar_evolution.particles[1].temperature, 2)
self.assertAlmostRelativeEqual(
stellar_evolution.particles[0].luminosity,
stellar_evolution.particles[1].luminosity, 2)
stellar_evolution.stop()
def xtest18(self):
print "Testing EVtwin calculate_core_mass"
instance = EVtwin()#redirection="none")
star = instance.particles.add_particle(Particle(mass=1|units.MSun))
instance.evolve_model(0.4|units.Gyr) # VERY short, for test speed up
central_hydrogen_abundance = star.get_chemical_abundance_profiles()[0][0]
self.assertTrue(central_hydrogen_abundance < 0.68) # some hydrogen is burned
self.assertTrue(central_hydrogen_abundance > 0.67) # ... but not that much yet
self.assertEqual(star.calculate_core_mass(core_H_abundance_limit=0.67), 0 | units.MSun)
self.assertAlmostEqual(star.calculate_core_mass(core_H_abundance_limit=0.71), 1 | units.MSun, 1)
# For test speed up, we use a weird core_H_abundance_limit to define the "hydrogen exhausted core"
limit = 0.68
expected_core_mass = 0.0123182798542 | units.MSun
self.assertAlmostEqual(star.calculate_core_mass(core_H_abundance_limit=limit), expected_core_mass, 3)
species_names = star.get_names_of_species()
self.assertEquals(species_names, ['h1', 'he4', 'c12', 'n14', 'o16', 'ne20', 'mg24', 'si28', 'fe56'])
h1_core_mass = star.calculate_core_mass(species=["h1"], core_H_abundance_limit=limit)
he4_core_mass = star.calculate_core_mass(species=["he4"], core_H_abundance_limit=limit)
c12_core_mass = star.calculate_core_mass(species=["c12"], core_H_abundance_limit=limit)
n14_core_mass = star.calculate_core_mass(species=["n14"], core_H_abundance_limit=limit)
o16_core_mass = star.calculate_core_mass(species=["o16"], core_H_abundance_limit=limit)
ne20_core_mass = star.calculate_core_mass(species=["ne20"], core_H_abundance_limit=limit)
mg24_core_mass = star.calculate_core_mass(species=["mg24"], core_H_abundance_limit=limit)
si28_core_mass = star.calculate_core_mass(species=["si28"], core_H_abundance_limit=limit)
fe56_core_mass = star.calculate_core_mass(species=["fe56"], core_H_abundance_limit=limit)
metal_core_mass = star.calculate_core_mass(species=["c12", "n14", "o16", "ne20", "mg24", "si28", "fe56"], core_H_abundance_limit=limit)
instance.stop()
self.assertAlmostRelativeEqual(h1_core_mass, expected_core_mass*0.68, 2)
self.assertAlmostRelativeEqual(he4_core_mass, expected_core_mass*0.30, 2)
self.assertAlmostRelativeEqual(metal_core_mass, expected_core_mass*0.02, 1)
self.assertAlmostRelativeEqual(expected_core_mass, he4_core_mass + metal_core_mass + h1_core_mass, 7)
self.assertAlmostRelativeEqual(metal_core_mass, c12_core_mass + n14_core_mass +
o16_core_mass + ne20_core_mass + mg24_core_mass + si28_core_mass + fe56_core_mass, 7)
def convert_star_to_hydro_model(M, t_end):
stellar_evolution = EVtwin()
star = stellar_evolution.particles.add_particle(Particle(mass=M))
stellar_evolution.evolve_model(t_end)
Ngas = 10000
sph_particles = convert_stellar_model_to_SPH(star, Ngas).gas_particles
stellar_evolution.stop()
return sph_particles
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 create_particles():
star = Particle()
star.mass = 3.0 | units.MSun
stellar_evolution = EVtwin()
se_star = stellar_evolution.particles.add_particle(star)
print("Evolving", star.mass, "star with",
stellar_evolution.__class__.__name__, "up to", 100 | units.Myr)
stellar_evolution.evolve_model(100 | units.Myr)
print("Creating SPH particles from the (1D) stellar evolution model")
sph_particles = convert_stellar_model_to_SPH(se_star, 1000).gas_particles
stellar_evolution.stop()
return sph_particles
def test9(self):
print "Test for saving and loading the stellar structure model"
filenames = ["test1.dump", "test2.dump"]
filenames = [os.path.join(get_path_to_results(), name) for name in filenames]
instance = EVtwin(redirection="none")
instance.parameters.verbosity = True
instance.particles.add_particles(Particles(mass=[0.5, 0.8] | units.MSun))
instance.evolve_model()
instance.particles.write_star_to_file(filenames)
copies = Particles(2)
copies.filename = filenames
instance.particles.add_particles(copies)
instance.evolve_model()
print instance.particles
self.assertAlmostRelativeEquals(instance.particles.temperature, [3644, 4783, 3644, 4783] | units.K, 3)
instance.stop()
def test4(self):
print "Testing max age stop condition..."
# masses = [.5, 1.0, 1.5] | units.MSun # Test with fewer particles for speed-up.
masses = [0.5] | units.MSun
max_age = 9.0 | units.Myr
number_of_stars = len(masses)
stars = Particles(number_of_stars)
for i, star in enumerate(stars):
star.mass = masses[i]
star.radius = 0.0 | units.RSun
# Initialize stellar evolution code
instance = EVtwin()
instance.initialize_code()
instance.parameters.verbosity = True
if instance.parameters.maximum_number_of_stars < number_of_stars:
instance.parameters.maximum_number_of_stars = number_of_stars
self.assertEqual(instance.parameters.max_age_stop_condition, 2e6 | units.Myr)
instance.parameters.max_age_stop_condition = max_age
self.assertEqual(instance.parameters.max_age_stop_condition, max_age)
instance.commit_parameters()
instance.particles.add_particles(stars)
# Let the code perform initialization actions after all particles have been created.
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
instance.evolve_model(end_time=8.0 | units.Myr)
from_code_to_model.copy()
for i in range(number_of_stars):
print stars[i].age.as_quantity_in(units.Myr)
self.assertTrue(stars[i].age >= 8.0 | units.Myr)
self.assertTrue(stars[i].age <= max_age)
self.assertTrue(stars[i].mass <= masses[i])
self.assertTrue(stars[i].time_step <= max_age)
self.assertRaises(
AmuseException,
instance.evolve_model,
end_time=2 * max_age,
expected_message="Error when calling 'evolve_for' of a 'EVtwin', errorcode "
"is 5, error is 'Age greater than maximum age limit.'",
)
instance.stop()
def test20(self):
print "Testing EVtwin manual mass transfer rate"
instance = EVtwin()
instance.parameters.verbosity = True
stars = instance.particles.add_particles(Particles(mass=[0.8, 0.8]|units.MSun))
stars[0].mass_transfer_rate = -1e-8|units.MSun/units.yr
instance.evolve_model()
# NOTE! no mass transfer during the initial step:
self.assertEqual(stars[0].mass, stars[1].mass)
age = stars[0].age
mass = stars[0].mass
instance.evolve_model()
self.assertTrue(stars[0].mass < stars[1].mass)
# NOTE 2! actual mass transfer rate 10x lower:
self.assertAlmostRelativeEqual((stars[0].mass-mass) / (stars[0].age-age), -1.0e-9|units.MSun/units.yr, 4)
instance.stop()
def create_particles():
star = Particle()
star.mass = 3.0 | units.MSun
stellar_evolution = EVtwin()
se_star = stellar_evolution.particles.add_particle(star)
print("Evolving", star.mass, "star with", stellar_evolution.__class__.__name__, "up to", 100 | units.Myr)
stellar_evolution.evolve_model(100 | units.Myr)
print("Creating SPH particles from the (1D) stellar evolution model")
sph_particles = convert_stellar_model_to_SPH(
se_star,
1000
).gas_particles
stellar_evolution.stop()
return sph_particles
def test4(self):
print "Testing max age stop condition..."
#masses = [.5, 1.0, 1.5] | units.MSun # Test with fewer particles for speed-up.
masses = [.5] | units.MSun
max_age = 9.0 | units.Myr
number_of_stars=len(masses)
stars = Particles(number_of_stars)
for i, star in enumerate(stars):
star.mass = masses[i]
star.radius = 0.0 | units.RSun
# Initialize stellar evolution code
instance = EVtwin()
instance.initialize_code()
instance.parameters.verbosity = True
if instance.parameters.maximum_number_of_stars < number_of_stars:
instance.parameters.maximum_number_of_stars = number_of_stars
self.assertEqual(instance.parameters.max_age_stop_condition, 2e6 | units.Myr)
instance.parameters.max_age_stop_condition = max_age
self.assertEqual(instance.parameters.max_age_stop_condition, max_age)
instance.commit_parameters()
instance.particles.add_particles(stars)
# Let the code perform initialization actions after all particles have been created.
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
instance.evolve_model(end_time = 8.0 | units.Myr)
from_code_to_model.copy()
for i in range(number_of_stars):
print stars[i].age.as_quantity_in(units.Myr)
self.assertTrue(stars[i].age >= 8.0 | units.Myr)
self.assertTrue(stars[i].age <= max_age)
self.assertTrue(stars[i].mass <= masses[i])
self.assertTrue(stars[i].time_step <= max_age)
self.assertRaises(AmuseException, instance.evolve_model, end_time = 2*max_age,
expected_message = "Error when calling 'evolve_for' of a 'EVtwin', errorcode "
"is 5, error is 'Age greater than maximum age limit.'")
instance.stop()
def slowtest5(self):
print "Test convert_SPH_to_stellar_model result in EVtwin"
stellar_evolution = EVtwin()
stellar_evolution.parameters.verbosity = True
stellar_evolution.particles.add_particle(Particle(mass=1.0|units.MSun)) # reference particle
stellar_evolution.evolve_model(100.0|units.Myr)
model = convert_SPH_to_stellar_model(self.new_particles()) # model is from center to surface
stellar_evolution.new_particle_from_model(model, 0.0|units.Myr)
print stellar_evolution.particles
self.assertAlmostEqual(stellar_evolution.particles.age, [100.0, 0.0] | units.Myr, 1)
stellar_evolution.evolve_model(200.0|units.Myr)
print stellar_evolution.particles
self.assertAlmostEqual(stellar_evolution.particles.age, [200.0, 100.0] | units.Myr, 1)
self.assertAlmostRelativeEqual(stellar_evolution.particles[0].temperature,
stellar_evolution.particles[1].temperature, 2)
self.assertAlmostRelativeEqual(stellar_evolution.particles[0].luminosity,
stellar_evolution.particles[1].luminosity, 2)
stellar_evolution.stop()
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 xtest10(self):
print "Test for changing the stellar composition (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()
composition = instance.particles[0].get_chemical_abundance_profiles()
h1_profile = composition[0] * 1
he4_profile = composition[1] * 1
k_surface = -1 # index to the outer mesh cell (surface)
self.assertAlmostEquals(composition[0, k_surface], 0.7 | units.none, 4)
self.assertAlmostEquals(composition[1, k_surface], (0.3 | units.none) - instance.parameters.metallicity, 4)
self.assertAlmostEquals(composition[2:, k_surface].sum(), instance.parameters.metallicity, 4)
composition[0] = he4_profile
composition[1] = h1_profile
instance.particles[0].set_chemical_abundance_profiles(composition)
instance.evolve_model()
composition = instance.particles[0].get_chemical_abundance_profiles()
self.assertAlmostEquals(composition[0, k_surface], (0.3 | units.none) - instance.parameters.metallicity, 4)
self.assertAlmostEquals(composition[1, k_surface], 0.7 | units.none, 4)
self.assertAlmostEquals(composition[2:, k_surface].sum(), instance.parameters.metallicity, 4)
self.assertAlmostEquals(composition.sum(axis=0), 1.0 | units.none)
self.assertRaises(
AmuseException,
instance.particles[0].set_chemical_abundance_profiles,
composition[:7],
expected_message="The length of the supplied vector (7) does not match the number of "
"chemical species of the star (8).",
)
instance.stop()
del instance
def test9(self):
print "Test for saving and loading the stellar structure model"
filenames = ["test1.dump", "test2.dump"]
filenames = [os.path.join(get_path_to_results(), name) for name in filenames]
instance = EVtwin()#redirection="none")
instance.parameters.verbosity = True
instance.particles.add_particles(Particles(mass = [0.5, 0.8] | units.MSun))
instance.evolve_model()
instance.particles.write_star_to_file(filenames)
copies = Particles(2)
copies.filename = filenames
instance.particles.add_particles(copies)
instance.evolve_model()
print instance.particles
import warnings
warnings.warn("this test's precision has been temporarily (2017) decreased")
# the reason for this is that the deviation is compiler dependend (and does only happen
# on some machine/compiler/OS combinations)
# it may have something to do with initialization of variables in evtwin
#~ self.assertAlmostRelativeEquals(instance.particles.temperature, [3644, 4783, 3644, 4783] | units.K, 3)
self.assertAlmostRelativeEquals(instance.particles.temperature, [3644, 4783, 3644, 4783] | units.K, 2)
instance.stop()
def new_particles(self):
input_file = os.path.join(get_path_to_results(), "test_sph_to_star_input.hdf5")
if os.path.exists(input_file):
return read_set_from_file(input_file, "hdf5")
stellar_evolution = EVtwin()
stellar_evolution.particles.add_particle(Particle(mass=1.0|units.MSun))
stellar_evolution.evolve_model(100.0|units.Myr)
particles = convert_stellar_model_to_SPH(
stellar_evolution.particles[0],
500,
seed=12345
).gas_particles
stellar_evolution.stop()
hydrodynamics = Gadget2(ConvertBetweenGenericAndSiUnits(1.0|units.MSun, 1.0|units.RSun, 1.0e3|units.s))
hydrodynamics.gas_particles.add_particles(particles)
hydrodynamics.evolve_model(1.0|units.s)
hydrodynamics.gas_particles.copy_values_of_attributes_to(["density", "u", "pressure"], particles)
hydrodynamics.stop()
write_set_to_file(particles, input_file, "hdf5")
return particles
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 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 new_particles(self):
input_file = os.path.join(get_path_to_results(),
"test_sph_to_star_input.hdf5")
if os.path.exists(input_file):
return read_set_from_file(input_file, "hdf5")
stellar_evolution = EVtwin()
stellar_evolution.particles.add_particle(
Particle(mass=1.0 | units.MSun))
stellar_evolution.evolve_model(100.0 | units.Myr)
particles = convert_stellar_model_to_SPH(
stellar_evolution.particles[0], 500, seed=12345).gas_particles
stellar_evolution.stop()
hydrodynamics = Gadget2(
ConvertBetweenGenericAndSiUnits(1.0 | units.MSun, 1.0 | units.RSun,
1.0e3 | units.s))
hydrodynamics.gas_particles.add_particles(particles)
hydrodynamics.evolve_model(1.0 | units.s)
hydrodynamics.gas_particles.copy_values_of_attributes_to(
["density", "u", "pressure"], particles)
hydrodynamics.stop()
write_set_to_file(particles, input_file, "hdf5")
return particles
def xtest10(self):
print "Test for changing the stellar composition (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()
composition = instance.particles[0].get_chemical_abundance_profiles()
h1_profile = composition[0] * 1
he4_profile = composition[1] * 1
k_surface = -1 # index to the outer mesh cell (surface)
self.assertAlmostEquals(composition[0, k_surface], 0.7 | units.none, 4)
self.assertAlmostEquals(composition[1, k_surface], (0.3 | units.none) - instance.parameters.metallicity, 4)
self.assertAlmostEquals(composition[2: , k_surface].sum(), instance.parameters.metallicity, 4)
composition[0] = he4_profile
composition[1] = h1_profile
instance.particles[0].set_chemical_abundance_profiles(composition)
instance.evolve_model()
composition = instance.particles[0].get_chemical_abundance_profiles()
self.assertAlmostEquals(composition[0, k_surface], (0.3 | units.none) - instance.parameters.metallicity, 4)
self.assertAlmostEquals(composition[1, k_surface], 0.7 | units.none, 4)
self.assertAlmostEquals(composition[2: , k_surface].sum(), instance.parameters.metallicity, 4)
self.assertAlmostEquals(composition.sum(axis=0), 1.0 | units.none)
self.assertRaises(AmuseException, instance.particles[0].set_chemical_abundance_profiles, composition[:7],
expected_message = "The length of the supplied vector (7) does not match the number of "
"chemical species of the star (8).")
instance.stop()
del instance
def xtest3(self):
instance = EVtwin()
instance.initialize_code()
instance.commit_parameters()
stars = Particles(1)
star = stars[0]
star.mass = 5.0 | units.MSun
star.radius = 0.0 | units.RSun
instance.particles.add_particles(stars)
instance.commit_particles()
from_code_to_model = instance.particles.new_channel_to(stars)
from_code_to_model.copy()
previous_type = star.stellar_type
results = []
t0 = 0 | units.Myr
current_time = t0
while current_time < (115 | units.Myr):
instance.evolve_model()
from_code_to_model.copy()
current_time = star.age
print (star.age, star.mass, star.stellar_type)
if not star.stellar_type == previous_type:
results.append((star.age, star.mass, star.stellar_type))
previous_type = star.stellar_type
print results
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)
instance.stop()