def test4(self): instance=SPHRay() instance.gas_particles.add_particle( Particle( mass = 1 | (10**10*units.MSun), x = 2 | units.kpc, y = 3 | units.kpc, z = 4 | units.kpc, h_smooth = 0.1 | (units.kpc), rho = 0.5 | ((10**10*units.MSun) /(units.kpc)**3), xion = 0.01, u = 0.2 | (10**5 * units.cm/units.s)**2 ) ) instance.src_particles.add_particle( Particle( luminosity = 1 | 1e48 * units.s**-1, x = 2 | units.m, y = 3 | units.m, z = 4 | units.m, SpcType = 12.3 ) ) instance.commit_particles() self.assertAlmostRelativeEquals(instance.src_particles.luminosity, 1 | 1e48 * units.s**-1, 6) self.assertAlmostRelativeEquals(instance.src_particles.x, 2 | units.m,7) self.assertAlmostRelativeEquals(instance.src_particles.y, 3 | units.m,7) self.assertAlmostRelativeEquals(instance.src_particles.z, 4 | units.m,7) self.assertAlmostRelativeEquals(instance.src_particles.SpcType, 12.3,7) print instance.src_particles instance.stop()
def crash_test(method=1): code=Kepler(redirection="none") code.set_method(method) smu=1.224744871391589 mu=smu**2 r0=2.787802728537455 rv0=-0.9899959571994231 alpha=0.01380749549277993 smudt=2.809925892593303 v02=(mu*(2/r0-alpha)) vx=rv0 vy=(v02-vx**2)**0.5 sun=Particle() sun.mass=mu | nbody_system.mass sun.x=0. | nbody_system.length sun.y=0. | nbody_system.length sun.z=0. | nbody_system.length sun.vx=0. | nbody_system.speed sun.vy=0. | nbody_system.speed sun.vz=0. | nbody_system.speed comet=Particle() comet.mass= 0 | nbody_system.mass comet.x=r0| nbody_system.length comet.y=0. | nbody_system.length comet.z=0. | nbody_system.length comet.vx=vx | nbody_system.speed comet.vy=vy | nbody_system.speed comet.vz=0. | nbody_system.speed tend=(smudt/smu) | nbody_system.time print tend code.central_particle.add_particle(sun) code.orbiters.add_particle(comet) a0,eps0=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz,G=nbody_system.G) print orbital_elements_from_binary(code.particles[0:2]) t1=time.time() code.evolve_model(tend) t2=time.time() print orbital_elements_from_binary(code.particles[0:2]) print code.orbiters.position a,eps=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz,G=nbody_system.G) da=abs((a-a0)/a0) deps=abs(eps-eps0)/eps0 print da,deps print "time:",t2-t1
def test_kepler_parabolic( tend=1,method=0, sign=+1): code=Kepler(redirection="none") code.set_method(method) sun=Particle() sun.mass=1. | nbody_system.mass sun.x=0. | nbody_system.length sun.y=0. | nbody_system.length sun.z=0. | nbody_system.length sun.vx=0. | nbody_system.speed sun.vy=0. | nbody_system.speed sun.vz=0. | nbody_system.speed comet=Particle() comet.mass= 0 | nbody_system.mass comet.x=1. | nbody_system.length comet.y=0. | nbody_system.length comet.z=0. | nbody_system.length comet.vx=0. | nbody_system.speed comet.vy=(1.0 + sign * 1.0e-10)*(2*nbody_system.G*sun.mass/comet.x)**0.5 comet.vz=0. | nbody_system.speed tend=tend | nbody_system.time print tend code.central_particle.add_particle(sun) code.orbiters.add_particle(comet) a0,eps0=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz,G=nbody_system.G) print orbital_elements_from_binary(code.particles[0:2]) t1=time.time() code.evolve_model(tend) t2=time.time() print orbital_elements_from_binary(code.particles[0:2]) print code.orbiters.position a,eps=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz,G=nbody_system.G) da=abs((a-a0)/a0) deps=abs(eps-eps0)/eps0 print da,deps print "time:",t2-t1
def result(self): if self.pickle_file is None: self.retrieve_stellar_structure() else: self.unpickle_stellar_structure() if self.with_core_particle: self.setup_core_parameters() sph_particles = self.convert_to_SPH() if self.do_relax: for result_string in self.relax(sph_particles): print(result_string) specific_internal_energy, composition, mu = self.interpolate_internal_energy( sph_particles.position.lengths(), do_composition_too = self.do_store_composition ) sph_particles.u = specific_internal_energy if self.do_store_composition: sph_particles.add_vector_attribute("composition", self.species_names) sph_particles.composition = composition sph_particles.mu = mu if self.with_core_particle and self.core_radius: core_particle = Particle() core_particle.mass = self.core_mass core_particle.position = [0.0, 0.0, 0.0] | units.m core_particle.velocity = [0.0, 0.0, 0.0] | units.m / units.s core_particle.radius = self.core_radius return StellarModelInSPH(gas_particles=sph_particles, core_particle=core_particle, core_radius=self.core_radius) return StellarModelInSPH(gas_particles=sph_particles, core_particle=None, core_radius=None)
def test18(self): print("MOSSE validation") mosse_src_path = os.path.join(os.path.dirname(sys.modules[MOSSE.__module__].__file__), 'src') if not os.path.exists(os.path.join(mosse_src_path, "evolve.in")): self.skip("Not in a source release") instance = MOSSE() instance.particles.add_particle(Particle(mass = 1.416 | units.MSun)) instance.particles[0].evolve_for(7000.0 | units.Myr) evolved_star = instance.particles.copy()[0] evolved_star.temperature = instance.particles[0].temperature instance.stop() testpath = get_path_to_results() shutil.copy(os.path.join(sse_src_path, "evolve.in"), os.path.join(testpath, "evolve.in")) call([os.path.join(sse_src_path, "mosse")], cwd=testpath) with open(os.path.join(testpath, "evolve.dat"), "r") as sse_output: lines = sse_output.readlines() sse_final_result = lines[-2].split() self.assertAlmostEqual(evolved_star.age, float(sse_final_result[0]) | units.Myr, 3) self.assertAlmostEqual(evolved_star.stellar_type, float(sse_final_result[1]) | units.stellar_type, 3) self.assertAlmostEqual(evolved_star.initial_mass, float(sse_final_result[2]) | units.MSun, 3) self.assertAlmostEqual(evolved_star.mass, float(sse_final_result[3]) | units.MSun, 3) self.assertAlmostEqual(evolved_star.luminosity, 10**float(sse_final_result[4]) | units.LSun, 3) self.assertAlmostEqual(evolved_star.radius, 10**float(sse_final_result[5]) | units.RSun, 3) self.assertAlmostRelativeEqual(evolved_star.temperature, 10**float(sse_final_result[6]) | units.K, 2) self.assertAlmostEqual(evolved_star.core_mass, float(sse_final_result[7]) | units.MSun, 3) self.assertAlmostEqual(evolved_star.convective_envelope_mass, float(sse_final_result[8]) | units.MSun, 3) self.assertAlmostEqual(evolved_star.epoch, float(sse_final_result[9]) | units.Myr, 3) self.assertAlmostEqual(evolved_star.spin, float(sse_final_result[10]) | units.yr**-1, 3)
def new_single_star(mass, pos, vel): single_star = Particle() single_star.mass = mass single_star.position = pos single_star.velocity = vel single_star.radius = 1.0 | units.RSun return single_star
def make_binary_star(mprim, msec, semimajor_axis, eccentricity): double_star = Particle() double_star.is_binary = True double_star.mass = mprim + msec double_star.semimajor_axis = semimajor_axis double_star.eccentricity = eccentricity period = (2 * numpy.pi * (semimajor_axis * semimajor_axis * semimajor_axis / (constants.G * double_star.mass)).sqrt()) print("Period =", period.as_string_in(units.yr)) stars = new_binary_from_orbital_elements(mprim, msec, semimajor_axis, eccentricity, G=constants.G) stars.is_binary = False double_star.child1 = stars[0] double_star.child1.name = "primary" double_star.child2 = stars[1] double_star.child2.name = "secondary" for star in stars: star.radius = (star.mass.value_in(units.MSun)**0.8) | units.RSun return double_star, stars
def test7(self): print "Testing Pikachu states" stars = new_plummer_model(100) black_hole = Particle() black_hole.mass = 1.0 | nbody_system.mass black_hole.radius = 0.0 | nbody_system.length black_hole.position = [0.0, 0.0, 0.0] | nbody_system.length black_hole.velocity = [0.0, 0.0, 0.0] | nbody_system.speed print "First do everything manually:" instance = self.new_instance_of_an_optional_code( Pikachu, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.initialize_code() self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') #~ instance.parameters.rcut_out_star_star = 1.0 | nbody_system.length instance.parameters.timestep = 0.001 | nbody_system.time instance.commit_parameters() self.assertEquals(instance.get_name_of_current_state(), 'EDIT') instance.particles.add_particles(stars) instance.commit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') instance.recommit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') instance.synchronize_model() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.cleanup_code() self.assertEquals(instance.get_name_of_current_state(), 'END') instance.stop() print "initialize_code(), commit_parameters(), (re)commit_particles(), " \ "synchronize_model(), and cleanup_code() should be called " \ "automatically before editing parameters, new_particle(), get_xx(), and stop():" instance = self.new_instance_of_an_optional_code( Pikachu, **default_options) self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.parameters.timestep = 0.001 | nbody_system.time self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.particles.add_particles(stars) self.assertEquals(instance.get_name_of_current_state(), 'EDIT') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.remove_particle(stars[0]) instance.particles.add_particle(black_hole) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.evolve_model(0.001 | nbody_system.time) self.assertEquals(instance.get_name_of_current_state(), 'EVOLVED') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.stop() self.assertEquals(instance.get_name_of_current_state(), 'STOPPED')
def structure_from_star(mass, age): stellar_evolution = EVtwin() star = stellar_evolution.particles.add_particle(Particle(mass=mass)) star.evolve_for(age) radius_profile = star.get_radius_profile() density_profile = star.get_density_profile() if hasattr(star, "get_mass_profile"): mass_profile = star.get_mass_profile() * star.mass else: radii_cubed = radius_profile**3 radii_cubed.prepend(0 | units.m**3) mass_profile = ( (4.0 / 3.0 * numpy.pi) * density_profile * (radii_cubed[1:] - radii_cubed[:-1]) ) print("Derived mass profile from density and radius.") return dict( radius=radius_profile.as_quantity_in(units.RSun), density=density_profile, mass=mass_profile, temperature=star.get_temperature_profile(), pressure=star.get_pressure_profile(), composition=star.get_chemical_abundance_profiles(), species_names=star.get_names_of_species() )
def test19(self): print("SSE core_mass and CO_core_mass (high mass star)") instance = SSE() star = instance.particles.add_particle(Particle(mass = 30 | units.MSun)) instance.evolve_model(5.8 | units.Myr) print(star.mass, star.core_mass, star.CO_core_mass, star.stellar_type) self.assertEqual(str(star.stellar_type), "Main Sequence star") self.assertIsOfOrder(star.mass, 30 | units.MSun) self.assertEqual(star.core_mass, 0 | units.MSun) self.assertEqual(star.CO_core_mass, 0 | units.MSun) instance.evolve_model(6.0 | units.Myr) print(star.mass, star.core_mass, star.CO_core_mass, star.stellar_type) self.assertEqual(str(star.stellar_type), "Core Helium Burning") self.assertIsOfOrder(star.mass, 30 | units.MSun) self.assertIsOfOrder(star.core_mass, 10 | units.MSun) self.assertEqual(star.CO_core_mass, 0 | units.MSun) instance.evolve_model(6.5 | units.Myr) print(star.mass, star.core_mass, star.CO_core_mass, star.stellar_type) self.assertEqual(str(star.stellar_type), "Main Sequence Naked Helium star") self.assertIsOfOrder(star.mass, 10 | units.MSun) self.assertEqual(star.core_mass, star.mass) self.assertEqual(star.CO_core_mass, 0 | units.MSun) instance.evolve_model(6.65 | units.Myr) print(star.mass, star.core_mass, star.CO_core_mass, star.stellar_type) self.assertEqual(str(star.stellar_type), "Hertzsprung Gap Naked Helium star") self.assertIsOfOrder(star.mass, 10 | units.MSun) self.assertEqual(star.core_mass, star.mass) self.assertAlmostEqual(star.CO_core_mass, 7.12 | units.MSun, 2) instance.evolve_model(7.0 | units.Myr) print(star.mass, star.core_mass, star.CO_core_mass, star.stellar_type) self.assertEqual(str(star.stellar_type), "Black Hole") self.assertIsOfOrder(star.mass, 10 | units.MSun) self.assertEqual(star.core_mass, star.mass) self.assertEqual(star.CO_core_mass, star.mass) instance.stop()
def test_kepler(N=10000, tend=1.| units.yr,method=0): numpy.random.seed(12345) conv=nbody_system.nbody_to_si(2.| units.MSun, 5.|units.AU) comets=new_plummer_model(N,conv) sun=Particle(mass=1.|units.MSun) sun.position=[0,0,0]|units.AU sun.velocity=[0,0,0]|units.kms comets.mass*=0. code=Kepler(conv,redirection="none") code.set_method(method) code.central_particle.add_particle(sun) code.orbiters.add_particles(comets) a0,eps0=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz) # print code.orbiters.x[0] print orbital_elements_from_binary(code.particles[0:2],constants.G) t1=time.time() code.evolve_model(tend) t2=time.time() print orbital_elements_from_binary(code.particles[0:2],constants.G) # print code.orbiters.x[0] a,eps=elements(sun.mass,code.orbiters.x,code.orbiters.y,code.orbiters.z, code.orbiters.vx,code.orbiters.vy,code.orbiters.vz) da=abs((a-a0)/a0) deps=abs(eps-eps0)/eps0 dev=numpy.where(da > 0.00001)[0] print len(dev) print a0[dev].value_in(units.AU) print eps0[dev] # pyplot.plot(a0[dev].value_in(units.AU),eps0[dev],"ro") # pyplot.plot(a[dev].value_in(units.AU),eps[dev],"g+") print "max da,deps:",da.max(), deps.max() print "time:",t2-t1 # pyplot.show() return t2-t1,da.max(),deps.max()
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 test12(self): N = 1000 Lstar = 100 | units.LSun boxsize = 10 | units.parsec rho = 1.0 | (units.amu / units.cm**3) t_end = 0.01 | units.Myr internal_energy = (9. | units.kms)**2 source = Particle() source.position = (0, 0, 0) | units.parsec source.flux = Lstar / (20. | units.eV) source.rho = rho source.xion = 0.0 source.u = internal_energy ism = ism_cube(N, boxsize / 2., rho, internal_energy).result ism.rho = rho ism.flux = 0. | units.s**-1 ism.xion = source.xion radiative = SimpleX() radiative.parameters.box_size = 1.001 * boxsize radiative.parameters.timestep = 0.001 | units.Myr radiative.particles.add_particle(source) radiative.particles.add_particles(ism) radiative.evolve_model(t_end) self.assertAlmostRelativeEquals(0.0750819123073, radiative.particles.xion.mean(), 1) radiative.stop()
def get_orbital_elements_from_binary(binary, G=nbody_system.G): """ Function that computes orbital elements from given two-particle set. Elements are computed for the second particle in this set and the return values are: mass1, mass2, semimajor axis, eccentricity, cosine of true anomaly, cosine of inclination, cosine of the longitude of the ascending node and the cosine of the argument of pericenter. In case of a perfectly circular orbit the true anomaly and argument of pericenter cannot be determined; in this case the return values are 1.0 for both cosines. """ primaries = Particles() secondaries = Particles() if len(binary) > 2: raise Exception("expects binary or single part") elif len(binary) == 2: primaries.add_particle(binary[0]) secondaries.add_particle(binary[1]) else: # FIXME: in case of one particle, what do we calculate the orbit of? # The method below is what was default before. primaries.add_particle(binary[0]) primaries[0].position *= 0 primaries[0].velocity *= 0 secondaries.add_particle(Particle()) secondaries[0].mass = 0 * primaries[0].mass secondaries[0].position = binary.position secondaries[0].velocity = binary.velocity (mass1, mass2, semimajor_axis, eccentricity, true_anomaly, inclination, long_asc_node, arg_per) = get_orbital_elements_from_binaries(primaries, secondaries, G=G) return (mass1[0], mass2[0], semimajor_axis[0], eccentricity[0], true_anomaly[0], inclination[0], long_asc_node[0], arg_per[0])
def form_new_star( densest_gas_particle, gas_particles, # density_threshold= ): """ Forms a new star by merging all gas particles within a Jeans radius of the densest particle. Returns the new star and all particles used to make it. """ new_star = Particle() gas_copy = gas_particles.copy() # densest_gas_particle = gas_copy.sorted_by_attribute("density")[0] jeans_radius = 0.025 | units.parsec # 100 | units.AU gas_copy.position -= densest_gas_particle.position gas_copy.distance_to_core = gas_copy.position.lengths() dense_gas = gas_copy.select(lambda x: x < jeans_radius, ["distance_to_core"]) new_star.mass = dense_gas.mass.sum() new_star.position = (dense_gas.center_of_mass() + densest_gas_particle.position) new_star.velocity = dense_gas.center_of_mass_velocity() new_star.radius = jeans_radius absorbed_gas = dense_gas return new_star, absorbed_gas
def continue_evolution(sph_code, dynamics_code, t_end, n_steps, relaxed_giant_output_base_name, do_energy_evolution_plot): print("Loading snapshots...", end=' ') files = os.listdir("snapshots") files.sort() files = files[-4:] print(files) binary = read_set_from_file(os.path.join("snapshots", files[0]), format='amuse') gd_particles = read_set_from_file(os.path.join("snapshots", files[1]), format='amuse') sph_particles = read_set_from_file(os.path.join("snapshots", files[2]), format='amuse') snapshotfile = os.path.join("..", "giant_models", relaxed_giant_output_base_name + "_core.amuse") core_particle = read_set_from_file(snapshotfile, format='amuse') giant_model = StellarModelInSPH( gas_particles = sph_particles, core_particle = gd_particles[0], core_radius = core_particle.radius) view_on_giant = Particle() view_on_giant.position = [0]*3 | units.m view_on_giant.velocity = [0]*3 | units.m / units.s print("\nSetting up {0} to simulate inner binary system".format(dynamics_code.__name__)) binary_system = prepare_binary_system(dynamics_code, binary) print("\nSetting up {0} to simulate giant in SPH".format(sph_code.__name__)) giant_system = prepare_giant_system(sph_code, giant_model, view_on_giant, t_end, n_steps) print("\nEvolving with bridge between", sph_code.__name__, "and", dynamics_code.__name__) evolve_coupled_system(binary_system, giant_system, t_end, n_steps, do_energy_evolution_plot, previous_data = os.path.join("snapshots", files[3])) print("Done")
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 brunt_vaisala_frequency_squared_profile(mass, age): stellar_evolution = MESA() star = stellar_evolution.particles.add_particle(Particle(mass=mass)) star.evolve_for(age) radius_profile = star.get_radius_profile() brunt_profile = star.get_brunt_vaisala_frequency_squared_profile() stellar_evolution.stop() return radius_profile.as_quantity_in(units.RSun), brunt_profile
def main(): temperatures_original = [] | units.K luminosities_original = [] | units.LSun temperatures_helium = [] | units.K luminosities_helium = [] | units.LSun star = Particle() star.mass = 12.0 | units.MSun stop_radius = 100 | units.RSun stellar_evolution = MESA() se_star = stellar_evolution.particles.add_particle(star) print("Evolving a", star.mass, "star with", stellar_evolution.__class__.__name__, end=' ') print("until its radius exceeds", stop_radius) while (se_star.radius < stop_radius): se_star.evolve_one_step() temperatures_original.append(se_star.temperature) luminosities_original.append(se_star.luminosity) ###BOOKLISTSTART1### number_of_zones = se_star.get_number_of_zones() composition = se_star.get_chemical_abundance_profiles() index = (composition[0] > 1.0e-9).nonzero()[0][0] # first zone with X > 1.0e-9 print("Creating helium star, from the inner", index, "(out of", str(number_of_zones)+") shells.") helium_star = stellar_evolution.new_particle_from_model(dict( mass = (se_star.get_cumulative_mass_profile() * se_star.mass)[:index], radius = se_star.get_radius_profile()[:index], rho = se_star.get_density_profile()[:index], temperature = se_star.get_temperature_profile()[:index], luminosity = se_star.get_luminosity_profile()[:index], X_H = composition[0][:index], X_He = composition[1][:index] + composition[2][:index], X_C = composition[3][:index], X_N = composition[4][:index], X_O = composition[5][:index], X_Ne = composition[6][:index], X_Mg = composition[7][:index], X_Si = composition[7][:index]*0.0, X_Fe = composition[7][:index]*0.0), 0.0 | units.Myr) ###BOOKLISTSTOP1### print("\nStar properties before helium star evolution:\n", stellar_evolution.particles) for i in range(1000): helium_star.evolve_one_step() temperatures_helium.append(helium_star.temperature) luminosities_helium.append(helium_star.luminosity) print("\nStar properties after helium star evolution:\n", stellar_evolution.particles) stellar_evolution.stop() return temperatures_original, luminosities_original, \ temperatures_helium, luminosities_helium
def test3(self): particles = Particles(2) particles.add_attribute_domain('a') particles.add_attribute_domain('b') particles.a.foo = 1 | units.m particles.b.foo = 2 | units.kg particles.foo = 3 | units.s particles.a.add_particle(Particle(foo=2 | units.m)) self.assertAlmostRelativeEqual(particles.a.foo, [1, 1, 2] | units.m) self.assertAlmostRelativeEqual(particles.b.foo, [2, 2, 0] | units.kg) self.assertAlmostRelativeEqual(particles.foo, [3, 3, 0] | units.s) particles.add_particle(Particle(foo=2 | units.s)) self.assertAlmostRelativeEqual(particles.a.foo, [1, 1, 2, 0] | units.m) self.assertAlmostRelativeEqual(particles.b.foo, [2, 2, 0, 0] | units.kg) self.assertAlmostRelativeEqual(particles.foo, [3, 3, 0, 2] | units.s)
def handle_collision(self, primary, secondary, stellar_evolution_code=None, gravity_code=None): primary = self.add_particle_with_internal_structure(primary, stellar_evolution_code=stellar_evolution_code) secondary = self.add_particle_with_internal_structure(secondary, stellar_evolution_code=stellar_evolution_code) merge_product = Particle( key = self.key_for_merge_product(primary, secondary), primary = primary, secondary = secondary ) return self.merge_products.add_particles(merge_product.as_set())
def new_particle_from_model(self, internal_structure, current_age, key=None): tmp_star = Particle(key=key) tmp_star.mass = internal_structure["mass"] tmp_star.radius = internal_structure["radius"] tmp_star.type = "new particle from model" return self.particles.add_particle(tmp_star)
def __init__(self, potential, particle=None): self.potential = potential if particle is None: particle = Particle() particle.position = [0., 0., 0.] | units.parsec particle.velocity = [0., 0., 0.] | units.kms self.particles = Particles() self.particles.add_particle(particle)
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 add_subsystem(self, sys, recenter=True): if len(sys) == 1: return self.add_particles(sys)[0] p = Particle() self.assign_parent_attributes(sys, p, relative=False, recenter=recenter) parent = self.add_particle(p) parent.subsystem = sys return parent
def xtest7(self): instance = self.new_instance_of_an_optional_code(SeBa) instance.parameters.metallicity = 0.03 p = Particle() p.mass = 99.1605930967 | units.MSun p = instance.particles.add_particle(p) instance.evolve_model(614 | units.Myr) print(p.stellar_type) self.assertEqual(str(p.stellar_type), 'Black Hole') self.assertAlmostRelativeEqual(p.mass, 0.9906 | units.MSun, 4)
def set_up_outer_star(inner_binary_mass): semimajor_axis = triple_parameters["a_out"] eccentricity = triple_parameters["eccentricity_out"] print " Initializing outer star" giant = Particle() giant.mass = triple_parameters["mass_out"] giant.position = semimajor_axis * (1 + eccentricity) * ([1, 0, 0] | units.none) giant.velocity = get_relative_velocity_at_apastron( giant.mass + inner_binary_mass, semimajor_axis, eccentricity) * ([0, 1, 0] | units.none) return giant
def set_up_outer_star(inner_binary_mass): semimajor_axis = 1.22726535008 | units.AU eccentricity = 0.15 inclination = math.radians(9.0) print(" Initializing outer star") giant = Particle() giant.mass = 5.5 | units.MSun giant.position = semimajor_axis * ([math.cos(inclination), 0, math.sin(inclination)] | units.none) giant.velocity = get_relative_velocity(giant.mass + inner_binary_mass, semimajor_axis, eccentricity) * ([0, 1, 0] | units.none) return giant
def stellar_lifetime(mZAMS, z=0.02): global se if se is None: se = SSE() se.parameters.metallicity = z se.particles.add_particle(Particle(mass=mZAMS)) while not stellar_remnant_state(se.particles[0]): se.evolve_model() t_end = se.particles[0].age # tpe = se.particles[0].stellar_type se.particles.remove_particle(se.particles[0]) return t_end