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
