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()