def generate_initial_population_grid(
min_mass, max_mass, number_of_mass_bins,
min_ratio, max_ratio, number_of_ratio_bins,
min_separation, max_separation, number_of_separation_bins,
min_eccentricity, max_eccentricity, number_of_eccentricity_bins
):
"""
creates a set of binaries and a set of stars, the grid
will be divided in equal parts amongst all dimensions (primary mass,
ratio and separation), the total number of binaries will
be the product of all bins.
"""
# quantities.linspace takes care of the units,
# but is otherwhise equal to numpy.arange
primary_masses = quantities.linspace(min_mass, max_mass, number_of_mass_bins)
mass_ratios = quantities.linspace(min_ratio, max_ratio, number_of_ratio_bins)
separations = quantities.linspace(min_separation, max_separation, number_of_separation_bins)
eccentricities = quantities.linspace(min_eccentricity, max_eccentricity, number_of_eccentricity_bins)
# We can create the binaries individualy (with nested for loops to
# go through each dimension) or at once with vector operations.
# As vector operations are handled by numpy (in C) these are
# much faster (default in this script).
if USE_VECTOR_OPERATIONS is True:
grid = multidimensional_meshgrid(primary_masses, mass_ratios, separations, eccentricities)
all_primary_masses = grid[0].flatten()
all_mass_ratios = grid[1].flatten()
all_separations = grid[2].flatten()
all_eccentricities = grid[3].flatten()
primary_stars = datamodel.Particles(mass=all_primary_masses)
secondary_stars = datamodel.Particles(mass=all_primary_masses * all_mass_ratios)
stars = datamodel.Particles()
primary_stars = stars.add_particles(primary_stars)
secondary_stars = stars.add_particles(secondary_stars)
binaries = datamodel.Particles(
semi_major_axis = all_separations,
eccentricity = all_eccentricities
)
binaries.child1 = list(primary_stars)
binaries.child2 = list(secondary_stars)
else:
for primary_mass in primary_masses:
for mass_ratio in mass_ratios:
for separation in separations:
for eccentricity in eccentricities :
create_binary(
stars,
binaries,
primary_mass,
mass_ratio,
separation,
eccentricity
)
return binaries, stars
def generate_initial_population_grid(min_mass, max_mass, number_of_mass_bins,
min_ratio, max_ratio,
number_of_ratio_bins, min_separation,
max_separation, number_of_separation_bins,
min_eccentricity, max_eccentricity,
number_of_eccentricity_bins):
"""
creates a set of binaries and a set of stars, the grid
will be divided in equal parts amongst all dimensions (primary mass,
ratio and separation), the total number of binaries will
be the product of all bins.
"""
# quantities.linspace takes care of the units,
# but is otherwhise equal to numpy.arange
primary_masses = quantities.linspace(min_mass, max_mass,
number_of_mass_bins)
mass_ratios = quantities.linspace(min_ratio, max_ratio,
number_of_ratio_bins)
separations = quantities.linspace(min_separation, max_separation,
number_of_separation_bins)
eccentricities = quantities.linspace(min_eccentricity, max_eccentricity,
number_of_eccentricity_bins)
# We can create the binaries individualy (with nested for loops to
# go through each dimension) or at once with vector operations.
# As vector operations are handled by numpy (in C) these are
# much faster (default in this script).
if USE_VECTOR_OPERATIONS is True:
grid = multidimensional_meshgrid(primary_masses, mass_ratios,
separations, eccentricities)
all_primary_masses = grid[0].flatten()
all_mass_ratios = grid[1].flatten()
all_separations = grid[2].flatten()
all_eccentricities = grid[3].flatten()
primary_stars = datamodel.Particles(mass=all_primary_masses)
secondary_stars = datamodel.Particles(mass=all_primary_masses *
all_mass_ratios)
stars = datamodel.Particles()
primary_stars = stars.add_particles(primary_stars)
secondary_stars = stars.add_particles(secondary_stars)
binaries = datamodel.Particles(semi_major_axis=all_separations,
eccentricity=all_eccentricities)
binaries.child1 = list(primary_stars)
binaries.child2 = list(secondary_stars)
else:
for primary_mass in primary_masses:
for mass_ratio in mass_ratios:
for separation in separations:
for eccentricity in eccentricities:
create_binary(stars, binaries, primary_mass,
mass_ratio, separation, eccentricity)
return binaries, stars
def test3(self):
array = quantities.linspace(0, 10, 11)
self.assertEquals(len(array), 11)
self.assertAlmostRelativeEquals(array,
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
def kira(tend, N, R, Nbin):
logging.basicConfig(level=logging.ERROR)
#encounters.LOG_ENERGY.setLevel(logging.DEBUG)
mass = new_salpeter_mass_distribution(N, mass_min=10 | units.MSun)
converter = nbody_system.nbody_to_si(mass.sum(), R)
code = Hermite(converter)
stars = new_plummer_model(N, convert_nbody=converter)
stars.mass = mass
stars.radius = 0.01 / len(stars) | R.unit
single_stars, binary_stars, singles_in_binaries = make_secondaries(
stars, Nbin)
print binary_stars
stellar = SeBa()
stellar.particles.add_particles(single_stars)
stellar.particles.add_particles(singles_in_binaries)
stellar.binaries.add_particles(binary_stars)
channel_to_stars = stellar.particles.new_channel_to(stars)
encounter_code = encounters.HandleEncounter(
kepler_code=new_kepler(converter),
resolve_collision_code=new_smalln(converter),
interaction_over_code=None,
G=constants.G)
multiples_code = encounters.Multiples(gravity_code=code,
handle_encounter_code=encounter_code,
G=constants.G)
multiples_code.particles.add_particles((stars - binary_stars).copy())
multiples_code.singles_in_binaries.add_particles(singles_in_binaries)
multiples_code.binaries.add_particles(binary_stars)
multiples_code.commit_particles()
channel_from_stars_to_particles = stellar.particles.new_channel_to(
multiples_code.particles)
stopping_condition = multiples_code.stopping_conditions.binaries_change_detection
stopping_condition.enable()
t = quantities.linspace(0 * tend, tend, 11)
for ti in t:
print "t, Energy=", ti, multiples_code.particles.mass.sum(
), multiples_code.get_total_energy()
multiples_code.evolve_model(ti)
print "at t=", multiples_code.model_time, "N-multiples:", len(
multiples_code.multiples)
if stopping_condition.is_set():
resolve_changed_binaries(stopping_condition, stellar, converter)
stellar.evolve_model(ti)
channel_from_stars_to_particles.copy_attributes(["mass", "radius"])
update_dynamical_binaries_from_stellar(stellar, multiples_code,
converter)
print "Lagrangian radii:", multiples_code.all_singles.LagrangianRadii(
converter)
print "MC.particles", multiples_code.particles
print "Lagrangian radii:", multiples_code.particles.LagrangianRadii(
converter)
print "t, Energy=", ti, multiples_code.get_total_energy()
multiples_code.stop()
stellar.stop()
def test2(self):
array = quantities.linspace(0 | units.kg, 10 | units.kg, 11)
self.assertEqual(len(array), 11)
self.assertAlmostRelativeEquals(
array, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] | units.kg)
def test3(self):
array = quantities.linspace(0 , 10 , 11)
self.assertEquals(len(array), 11)
self.assertAlmostRelativeEquals(array, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
def kira(tend, N, R, Nbin):
logging.basicConfig(level=logging.ERROR)
mass = new_salpeter_mass_distribution(N, mass_min=10 | units.MSun)
converter = nbody_system.nbody_to_si(mass.sum(), R)
code = Hermite(converter)
stars = new_plummer_model(N, convert_nbody=converter)
stars.mass = mass
stars.radius = 0.01 / len(stars) | R.unit
single_stars, binary_stars, singles_in_binaries \
= make_secondaries(stars, Nbin)
print binary_stars
stellar = SeBa()
stellar.particles.add_particles(single_stars)
stellar.particles.add_particles(singles_in_binaries)
stellar.binaries.add_particles(binary_stars)
channel_to_stars = stellar.particles.new_channel_to(stars)
encounter_code = encounters.HandleEncounter(
kepler_code=new_kepler(converter),
resolve_collision_code=new_smalln(converter),
interaction_over_code=None,
G=constants.G)
multiples_code = encounters.Multiples(gravity_code=code,
handle_encounter_code=encounter_code,
G=constants.G)
multiples_code.particles.add_particles((stars - binary_stars).copy())
multiples_code.singles_in_binaries.add_particles(singles_in_binaries)
multiples_code.binaries.add_particles(binary_stars)
multiples_code.commit_particles()
channel_from_stars_to_particles \
= stellar.particles.new_channel_to(multiples_code.particles)
stopping_condition \
= multiples_code.stopping_conditions.binaries_change_detection
stopping_condition.enable()
from matplotlib import pyplot
from distinct_colours import get_distinct
pyplot.rcParams.update({'font.size': 30})
figure = pyplot.figure(figsize=(12, 9))
ax = pyplot.gca()
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.xaxis._autolabelpos = True
ax.yaxis._autolabelpos = True
color = get_distinct(2)
pyplot.scatter(numpy.log10(
stellar.binaries.semi_major_axis.value_in(units.AU)),
stellar.binaries.eccentricity,
c=color[0],
s=200,
lw=0)
t = quantities.linspace(0 * tend, tend, 11)
for ti in t:
print "t, Energy=", ti, multiples_code.particles.mass.sum(), \
multiples_code.get_total_energy()
multiples_code.evolve_model(ti)
print "at t=", multiples_code.model_time, \
"Nmultiples:", len(multiples_code.multiples)
if stopping_condition.is_set():
resolve_changed_binaries(stopping_condition, stellar, converter)
stellar.evolve_model(ti)
channel_from_stars_to_particles.copy_attributes(["mass", "radius"])
update_dynamical_binaries_from_stellar(stellar, multiples_code,
converter)
print "Lagrangian radii:", \
multiples_code.all_singles.LagrangianRadii(converter)
print "MC.particles", multiples_code.particles
print "Lagrangian radii:", \
multiples_code.particles.LagrangianRadii(converter)
print "t, Energy=", ti, multiples_code.get_total_energy()
pyplot.scatter(numpy.log10(
stellar.binaries.semi_major_axis.value_in(units.AU)),
stellar.binaries.eccentricity,
c=color[1],
lw=0,
s=50)
pyplot.xlabel("$\log_{10}(a/R_\odot)$")
pyplot.ylabel("eccentricity")
save_file = 'kira_a_vs_e.pdf'
pyplot.savefig(save_file)
print '\nSaved figure in file', save_file, '\n'
pyplot.show()
stellar.stop()
