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 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 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 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 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 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 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 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 new_system(star_mass=1 | units.MSun,
star_radius=1 | units.RSun,
disk_minimum_radius=0.05 | units.AU,
disk_maximum_radius=10 | units.AU,
disk_mass=20 | MEarth,
accurancy=0.0001,
planet_density=3 | units.g / units.cm**3,
rng=None,
kepler=None):
central_particle = Particle()
central_particle.mass = star_mass
central_particle.position = (0, 0, 0) | units.AU
central_particle.velocity = (0, 0, 0) | units.kms
central_particle.radius = star_radius
central_particle.name = "star"
central_particle.type = "star"
central_particle.id = 0
if rng is None:
rng = numpy.random
converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
if kepler is None:
kepler = Kepler(converter)
kepler.initialize_code()
m, r, f = new_planet_distribution(disk_minimum_radius, disk_maximum_radius,
disk_mass, accurancy)
planets = make_planets(central_particle,
m,
r,
density=planet_density,
phi=0,
theta=None,
kepler=kepler,
rng=rng)
planets.name = "planet"
planets.type = "planet"
for i in range(len(planets)):
planets[i].id = i
central_particle.planets = planets
kepler.stop()
p = Particles()
p.add_particle(central_particle)
return p
def get_moons_for_planet(planet, delta_JD=0. | units.day):
"""
The Earth's moon
as for JD = 2457099.500000000 = A.D. 2015-Mar-18 00:00:00.0000 (CT)
https://ssd.jpl.nasa.gov/?sat_elem
"""
data = numpy.array([tuple(entry) for entry in _lunar_data],
dtype=[('planet_name', 'S10'), ('name', 'S10'),
('mass', '<f8'), ('radius', '<f8'),
('semimajor_axis', '<f8'),
('eccentricity', '<f8'),
('argument_of_peri', '<f8'),
('mean_anomaly', '<f8'), ('inclination', '<f8'),
('longitude_oan', '<f8')])
moon_data = data[data['planet_name'] == planet.name.encode('UTF-8')]
print("Planet=", planet.name, "moon=", moon_data["name"])
moons = Particles()
if len(moon_data["name"]):
print(len(moon_data["name"]))
for moon in moon_data:
#Ignore the moon for now, because it's complicated
if planet.name == "EarthMoon":
planet.mass -= moon["mass"] * 1.e+16 | units.kg
planet.name = "Earth"
#print moon
r, v = get_position(planet.mass,
moon["mass"] * 1.e+16 | units.kg,
moon["eccentricity"],
moon["semimajor_axis"] | units.km,
numpy.deg2rad(moon["mean_anomaly"]),
numpy.deg2rad(moon["inclination"]),
numpy.deg2rad(moon["longitude_oan"]),
numpy.deg2rad(moon["argument_of_peri"]),
delta_t=delta_JD)
single_moon = Particle()
single_moon.type = "moon"
single_moon.name = moon["name"]
single_moon.mass = moon["mass"] * 1.e+16 | units.kg
single_moon.hostname = moon["planet_name"]
single_moon.radius = moon["radius"] | units.km
single_moon.position = r
single_moon.position += planet.position
single_moon.velocity = v
single_moon.velocity += planet.velocity
moons.add_particle(single_moon)
return moons
def new_particle_from_cluster_core(particles,
unit_converter=None,
density_weighting_power=2,
cm=None,
reuse_hop=False,
hop=HopContainer()):
"""
Uses Hop to find the density centre (core) of a particle distribution
and stores the properties of this core on a particle:
position, velocity, (core) radius and (core) density.
Particles are assigned weights that depend on the density (as determined by
Hop) to a certain power.
The default weighting power is 2, which is most commonly used. Set
density_weighting_power to 1 in order to get the original weighting of
Casertano & Hut (1985, ApJ, 298, 80).
:argument unit_converter: Required if the particles are in SI units
:argument density_weighting_power: Particle properties are weighted by density to this power
"""
if isinstance(hop, HopContainer):
hop.initialize(unit_converter)
hop = hop.code
in_hop = hop.particles.add_particles(particles)
hop.parameters.density_method = 2
hop.parameters.number_of_neighbors_for_local_density = 7
hop.calculate_densities()
density = in_hop.density.copy()
if not reuse_hop:
hop.stop()
weights = (density**density_weighting_power).reshape((-1, 1))
# Reshape makes sure that density can be multiplied with vectors, e.g. position
result = Particle()
result.density = density.amax()
total_weight = weights.sum()
if cm is None:
result.position = (weights *
particles.position).sum(axis=0) / total_weight
else:
result.position = cm
result.velocity = (weights * particles.velocity).sum(axis=0) / total_weight
result.radius = (
weights.flatten() *
(particles.position - result.position).lengths()).sum() / total_weight
return result
def new_system(
star_mass = 1|units.MSun,
star_radius = 1|units.RSun,
disk_minumum_radius = 0.05 | units.AU,
disk_maximum_radius = 10 | units.AU,
disk_mass = 20 | MEarth,
accurancy = 0.0001,
planet_density = 3 | units.g/units.cm**3,
rng = None,
kepler = None):
central_particle = Particle()
central_particle.mass = star_mass
central_particle.position = (0,0,0) | units.AU
central_particle.velocity = (0,0,0) | units.kms
central_particle.radius = star_radius
if rng is None:
rng = numpy.random
converter = nbody_system.nbody_to_si(1|units.MSun, 1 | units.AU)
if kepler is None:
kepler = Kepler(converter)
kepler.initialize_code()
m, r, f = new_planet_distribution(
disk_minumum_radius, disk_maximum_radius,
disk_mass,
accurancy
)
planets = make_planets(
central_particle,
m, r,
density = planet_density,
phi = 0, theta = None,
kepler = kepler,
rng = rng
)
central_particle.planets = planets
kepler.stop()
p = Particles()
p.add_particle(central_particle)
return p
def old_new_solar_system():
"""
Create initial conditions describing the solar system. Returns a single
particle set containing the sun, planets and Pluto. The model is centered at
the origin (center-of-mass(-velocity) coordinates).
Defined attributes:
name, mass, radius, x, y, z, vx, vy, vz
"""
sun = Particle()
sun.name = 'SUN'
sun.mass = 1.0 | units.MSun
sun.radius = 1.0 | units.RSun
planets = _planets_only()
particles = Particles()
particles.add_particle(sun)
particles.add_particles(planets)
particles.move_to_center()
return particles
def get_moons_for_planet(planet, delta_JD=0.|units.day):
"""
The Earth's moon
as for JD = 2457099.500000000 = A.D. 2015-Mar-18 00:00:00.0000 (CT)
https://ssd.jpl.nasa.gov/?sat_elem
"""
data = numpy.array([tuple(entry) for entry in _lunar_data],
dtype=[('planet_name','S10'), ('name','S10'),
('mass','<f8'), ('radius','<f8'), ('semimajor_axis','<f8'),
('eccentricity','<f8'), ('argument_of_peri','<f8'),
('mean_anomaly','<f8'), ('inclination','<f8'), ('longitude_oan','<f8')])
moon_data = data[data['planet_name']==planet.name]
print "Planet=", planet.name, "moon=", moon_data["name"]
moons = Particles()
if len(moon_data["name"]):
print len(moon_data["name"])
for moon in moon_data:
#print moon
r, v = get_position(planet.mass,
moon["mass"] * 1.e+16 | units.kg,
moon["eccentricity"],
moon["semimajor_axis"]|units.km,
numpy.deg2rad(moon["mean_anomaly"]),
numpy.deg2rad(moon["inclination"]),
numpy.deg2rad(moon["longitude_oan"]),
numpy.deg2rad(moon["argument_of_peri"]),
delta_t=delta_JD)
single_moon = Particle()
single_moon.type = "moon"
single_moon.name = moon["name"]
single_moon.mass = moon["mass"] * 1.e+16 | units.kg
single_moon.hostname = moon["planet_name"]
single_moon.radius = moon["radius"] | units.km
single_moon.position = r
single_moon.position += planet.position
single_moon.velocity = v
single_moon.velocity += planet.velocity
moons.add_particle(single_moon)
return moons
def new_particle_from_cluster_core(
particles, unit_converter=None, density_weighting_power=2, cm=None, reuse_hop=False, hop=HopContainer()
):
"""
Uses Hop to find the density centre (core) of a particle distribution
and stores the properties of this core on a particle:
position, velocity, (core) radius and (core) density.
Particles are assigned weights that depend on the density (as determined by
Hop) to a certain power.
The default weighting power is 2, which is most commonly used. Set
density_weighting_power to 1 in order to get the original weighting of
Casertano & Hut (1985, ApJ, 298, 80).
:argument unit_converter: Required if the particles are in SI units
:argument density_weighting_power: Particle properties are weighted by density to this power
"""
if isinstance(hop, HopContainer):
hop.initialize(unit_converter)
hop = hop.code
in_hop = hop.particles.add_particles(particles)
hop.parameters.density_method = 2
hop.parameters.number_of_neighbors_for_local_density = 7
hop.calculate_densities()
density = in_hop.density.copy()
if not reuse_hop:
hop.stop()
weights = (density ** density_weighting_power).reshape((-1, 1))
# Reshape makes sure that density can be multiplied with vectors, e.g. position
result = Particle()
result.density = density.amax()
total_weight = weights.sum()
if cm is None:
result.position = (weights * particles.position).sum(axis=0) / total_weight
else:
result.position = cm
result.velocity = (weights * particles.velocity).sum(axis=0) / total_weight
result.radius = (weights.flatten() * (particles.position - result.position).lengths()).sum() / total_weight
return result
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" | units.string
return self.particles.add_particle(tmp_star)
