def integrate_system(N, t_end, seed=None):
total_mass = N | units.MSun
length = 1 | units.parsec
converter = nbody_system.nbody_to_si(total_mass, length)
gravity = ph4(convert_nbody=converter)
gravity.initialize_code()
gravity.parameters.set_defaults()
gravity.parameters.epsilon_squared = (0.0 | units.parsec)**2
if seed is not None: numpy.random.seed(seed)
stars = new_plummer_model(N, convert_nbody=converter)
stars.mass = total_mass / N
stars.scale_to_standard(
convert_nbody=converter,
smoothing_length_squared=gravity.parameters.epsilon_squared)
id = numpy.arange(N)
stars.id = id + 1
stars.radius = 0.5 / N | units.parsec
gravity.particles.add_particles(stars)
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
init_smalln(converter)
kep = Kepler(unit_converter=converter)
kep.initialize_code()
multiples_code = multiples.Multiples(gravity, new_smalln, kep, constants.G)
multiples_code.neighbor_perturbation_limit = 0.05
multiples_code.global_debug = 1
###BOOKLISTSTOP2###
# global_debug = 0: no output from multiples
# 1: minimal output
# 2: debugging output
# 3: even more output
print('')
print('multiples_code.neighbor_veto =', \
multiples_code.neighbor_veto)
print('multiples_code.neighbor_perturbation_limit =', \
multiples_code.neighbor_perturbation_limit)
print('multiples_code.retain_binary_apocenter =', \
multiples_code.retain_binary_apocenter)
print('multiples_code.wide_perturbation_limit =', \
multiples_code.wide_perturbation_limit)
time = numpy.sqrt(length**3 / (constants.G * total_mass))
print('\ntime unit =', time.in_(units.Myr))
###BOOKLISTSTART3###
E0 = print_diagnostics(multiples_code)
multiples_code.evolve_model(t_end)
print_diagnostics(multiples_code, E0)
###BOOKLISTSTOP3###
gravity.stop()
kep.stop()
stop_smalln()
def integrate_system(N, t_end, seed=None):
gravity = ph4()
gravity.initialize_code()
gravity.parameters.set_defaults()
if seed is not None: numpy.random.seed(seed)
stars = new_plummer_model(N)
stars.mass = 1./N | nbody_system.mass
stars.scale_to_standard(smoothing_length_squared
= gravity.parameters.epsilon_squared)
id = numpy.arange(N)
stars.id = id+1
# Set dynamical radii for encounters.
stars.radius = 0.5*stars.mass.number | nbody_system.length
gravity.particles.add_particles(stars)
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
init_smalln()
kep = Kepler(unit_converter=None)
kep.initialize_code()
multiples_code = multiples.Multiples(gravity, new_smalln, kep)
multiples_code.neighbor_perturbation_limit = 0.05
multiples_code.global_debug = 1
# global_debug = 0: no output from multiples
# 1: minimal output
# 2: debugging output
# 3: even more output
print('')
print('multiples_code.neighbor_veto =', \
multiples_code.neighbor_veto)
print('multiples_code.neighbor_perturbation_limit =', \
multiples_code.neighbor_perturbation_limit)
print('multiples_code.retain_binary_apocenter =', \
multiples_code.retain_binary_apocenter)
print('multiples_code.wide_perturbation_limit =', \
multiples_code.wide_perturbation_limit)
# Advance the system.
E0 = print_diagnostics(multiples_code)
multiples_code.evolve_model(t_end)
print_diagnostics(multiples_code, E0)
gravity.stop()
kep.stop()
stop_smalln()
def read_state_from_file(restart_file, gravity_code,
resolve_collision_code_creation_function, kep):
stars = io.read_set_from_file(restart_file + ".stars.hdf5",
'hdf5',
version='2.0').copy()
stars_python = io.read_set_from_file(restart_file + ".stars_python.hdf5",
'hdf5',
version='2.0').copy()
with open(restart_file + ".bookkeeping", "rb") as f:
bookkeeping = pickle.load(f)
if os.path.isfile(restart_file + ".extra_stuff"):
with open(restart_file + ".extra_stuff", "rb") as f:
extra_stuff = pickle.load(f)
else:
extra_stuff = None
print bookkeeping
root_to_tree = {}
for root in stars:
if hasattr(root, 'components') and not root.components is None:
root_to_tree[root] = datamodel.trees.BinaryTreeOnParticle(
root.components[0])
gravity_code.set_begin_time(bookkeeping['model_time'])
gravity_code.particles.add_particles(stars)
gravity_code.commit_particles()
multiples_code = multiples.Multiples(
gravity_code, resolve_collision_code_creation_function, kep)
#multiples_code.neighbor_distance_factor = 1.0
#multiples_code.neighbor_veto = False
#multiples_code.neighbor_distance_factor = 2.0
#multiples_code.neighbor_veto = True
multiples_code.neighbor_distance_factor = bookkeeping[
'neighbor_distance_factor']
multiples_code.neighbor_veto = bookkeeping['neighbor_veto']
multiples_code.multiples_external_tidal_correction = bookkeeping[
'multiples_external_tidal_correction']
multiples_code.multiples_integration_energy_error = bookkeeping[
'multiples_integration_energy_error']
multiples_code.multiples_internal_tidal_correction = bookkeeping[
'multiples_internal_tidal_correction']
multiples.root_index = bookkeeping['root_index']
multiples_code.root_to_tree = root_to_tree
#multiples_code.set_model_time = bookkeeping['model_time']
with open(restart_file + ".conf", "rb") as f:
config = pickle.load(f)
random.setstate(pickle.loads(config["py_seed"]))
numpy.random.set_state(pickle.loads(config["numpy_seed"]))
return stars_python, bookkeeping['model_time'], multiples_code, extra_stuff
def read_state_from_file(restart_file, gravity_code, kep, MT=0):
# Function to load from file. If you change params in
# write_state_to_file, make sure you match the changes here.
stars = io.read_set_from_file(restart_file + ".stars.hdf5",
'amuse',
version='2.0',
close_file=True).copy()
stars_python = io.read_set_from_file(restart_file + ".stars_python.hdf5",
'amuse',
version='2.0',
close_file=True).copy()
with open(restart_file + ".params", "rb") as f:
params = pickle.load(f)
f.close()
if MT == 0:
root_to_tree = {}
for root in stars:
if hasattr(root, 'components') and not root.components is None:
root_to_tree[root] \
= datamodel.trees.BinaryTreeOnParticle(root.components[0])
else:
root_to_tree = MT
gravity_code.parameters.timestep_parameter = params['timestep_parameter']
gravity_code.parameters.epsilon_squared = params['epsilon_squared']
gravity_code.particles.add_particles(stars)
gravity_code.commit_particles() # sets time steps
multiples_code = multiples.Multiples(gravity_code, new_smalln, kep)
multiples_code.neighbor_veto = params['neighbor_veto']
multiples_code.multiples_external_tidal_correction \
= params['multiples_external_tidal_correction']
multiples_code.multiples_integration_energy_error \
= params['multiples_integration_energy_error']
multiples_code.multiples_internal_tidal_correction \
= params['multiples_internal_tidal_correction']
multiples.root_index = params['root_index']
multiples_code.root_to_tree = root_to_tree
print("\nread state from file ", restart_file, \
'at time', params['model_time'])
return stars_python, params['model_time'], params['delta_t'], \
params['EZero'], params['CPUZero'], multiples_code
def read_state_from_file(restart_file, gravity_code, kep, SMALLN):
stars = read_set_from_file(restart_file + ".stars.hdf5",
'hdf5',
version='2.0',
close_file=True).copy()
# single_stars = read_set_from_file(restart_file+".singles.hdf5",'hdf5',version='2.0')
# multiple_stars = read_set_from_file(restart_file+".coms.hdf5",'hdf5',version='2.0')
stars_python = read_set_from_file(restart_file + ".stars_python.hdf5",
'hdf5',
version='2.0',
close_file=True).copy()
with open(restart_file + ".bookkeeping", "rb") as f:
bookkeeping = pickle.load(f)
f.close()
print bookkeeping
root_to_tree = {}
for root in stars:
if hasattr(root, 'components') and not root.components is None:
root_to_tree[root] = datamodel.trees.BinaryTreeOnParticle(
root.components[0])
gravity_code.particles.add_particles(stars)
# print bookkeeping['model_time']
# gravity_code.set_begin_time = bookkeeping['model_time']
multiples_code = multiples.Multiples(gravity_code, SMALLN, kep)
# multiples_code.neighbor_distance_factor = 1.0
# multiples_code.neighbor_veto = False
# multiples_code.neighbor_distance_factor = 2.0
# multiples_code.neighbor_veto = True
multiples_code.neighbor_distance_factor = bookkeeping[
'neighbor_distance_factor']
multiples_code.neighbor_veto = bookkeeping['neighbor_veto']
multiples_code.multiples_external_tidal_correction = bookkeeping[
'multiples_external_tidal_correction']
multiples_code.multiples_integration_energy_error = bookkeeping[
'multiples_integration_energy_error']
multiples_code.multiples_internal_tidal_correction = bookkeeping[
'multiples_internal_tidal_correction']
multiples.root_index = bookkeeping['root_index']
multiples_code.root_to_tree = root_to_tree
# multiples_code.set_model_time = bookkeeping['model_time']
return stars_python, multiples_code
def new_multiples_code(gravity, converter):
"""
Initialise a multiples instance with specified gravity code.
The gravity code must support stopping conditions (collision detection).
"""
gravity.parameters.epsilon_squared = (0.0 | units.parsec)**2
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
init_smalln(converter)
kep = Kepler(unit_converter=converter)
kep.initialize_code()
multiples_code = multiples.Multiples(
gravity,
new_smalln,
kep,
constants.G,
)
multiples_code.neighbor_perturbation_limit = 0.05
multiples_code.global_debug = 0
return multiples_code
sys.stdout.flush()
# Adding and Committing Particles to PH4
gravity.particles.add_particles(MasterSet)
gravity.commit_particles()
# Starting the AMUSE Channel for PH4
grav_channel = gravity.particles.new_channel_to(MasterSet)
# Initializing Kepler and SmallN
kep = Kepler(None, redirection="none")
kep.initialize_code()
util.init_smalln()
# Initializing MULTIPLES
multiples_code = multiples.Multiples(gravity, util.new_smalln, kep)
multiples_code.neighbor_distance_factor = 1.0
multiples_code.neighbor_veto = True
multiples_code.evolve_model(time)
gravity.synchronize_model()
# Copy values from the module to the set in memory.
grav_channel.copy()
# Copy the index (ID) as used in the module to the id field in
# memory. The index is not copied by default, as different
# codes may have different indices for the same particle and
# we don't want to overwrite silently.
grav_channel.copy_attribute("index_in_code", "id")
write.write_state_to_file(time, MasterSet, gravity, multiples_code, write_file)
def __init__(self,
nstars=10,
endtime=10,
total_mass=1000,
rscale=1.0,
interaction_radius=-1.0,
star_code='hermite',
star_smoothing_fraction=0.0,
seed=-1,
ntimesteps=10,
must_do_plot=True,
**ignored_options):
if seed >= 0:
numpy.random.seed(seed)
if interaction_radius < 0.0:
self.interaction_radius = 0.01 | nbody_system.length
else:
self.interaction_radius = interaction_radius | nbody_system.length
self.must_do_plot = must_do_plot
self.line = None
self.line2 = None
self.ntimesteps = ntimesteps
self.nstars = nstars
self.total_mass = total_mass | nbody_system.mass
self.rscale = rscale | nbody_system.length
self.star_epsilon = star_smoothing_fraction * self.rscale
self.star_mass = self.total_mass
self.endtime = endtime | nbody_system.time
self.delta_t = self.endtime / self.ntimesteps
self.create_code(star_code)
self.code = multiples.Multiples(self.star_code, self.new_smalln)
time = 0
sum_energy = self.code.kinetic_energy + self.code.potential_energy
energy0 = sum_energy.value_in(nbody_system.energy)
coreradius = self.star_code.particles.virial_radius().value_in(
self.rscale.to_unit())
print("Time :", time)
print("Energy :", energy0)
print("Virial radius :", coreradius)
self.evolve_model()
if must_do_plot:
pylab.show()
pylab.savefig("multiples-{0}-{1}.png".format(star_code, nstars))
time = self.code.model_time.value_in(nbody_system.time)
sum_energy = self.code.kinetic_energy + \
self.code.potential_energy - self.code.multiples_energy_correction
energy = sum_energy.value_in(nbody_system.energy)
coreradius = self.star_code.particles.virial_radius().value_in(
self.rscale.to_unit())
print("Time :", time)
print("Energy :", energy)
print("Delta E :", (energy - energy0) / energy0)
print("Virial radius :", coreradius)
self.stop()
if must_do_plot:
input('Press enter...')
def run_ph4(infile = None, outfile = None,
number_of_stars = 100, number_of_binaries = 0,
end_time = 10 | nbody_system.time,
delta_t = 1 | nbody_system.time,
n_workers = 1, use_gpu = 1, gpu_worker = 1,
salpeter = 0,
accuracy_parameter = 0.1,
softening_length = 0.0 | nbody_system.length,
manage_encounters = 1, random_seed = 1234):
if random_seed <= 0:
numpy.random.seed()
random_seed = numpy.random.randint(1, pow(2,31)-1)
numpy.random.seed(random_seed)
print "random seed =", random_seed
if infile != None: print "input file =", infile
print "end_time =", end_time.number
print "delta_t =", delta_t.number
print "n_workers =", n_workers
print "use_gpu =", use_gpu
print "manage_encounters =", manage_encounters
print "\ninitializing the gravity module"
sys.stdout.flush()
init_smalln()
# Note that there are actually three GPU options:
#
# 1. use the GPU code and allow GPU use (default)
# 2. use the GPU code but disable GPU use (-g)
# 3. use the non-GPU code (-G)
if gpu_worker == 1:
try:
gravity = grav(number_of_workers = n_workers,
redirection = "none", mode = "gpu")
except Exception as ex:
gravity = grav(number_of_workers = n_workers,
redirection = "none")
else:
gravity = grav(number_of_workers = n_workers,
redirection = "none")
gravity.initialize_code()
gravity.parameters.set_defaults()
#-----------------------------------------------------------------
if infile == None:
print "making a Plummer model"
stars = new_plummer_model(number_of_stars)
id = numpy.arange(number_of_stars)
stars.id = id+1
print "setting particle masses and radii"
if salpeter == 0:
print 'equal masses'
total_mass = 1.0 | nbody_system.mass
scaled_mass = total_mass / number_of_stars
else:
print 'salpeter mass function'
scaled_mass = new_salpeter_mass_distribution_nbody(number_of_stars)
stars.mass = scaled_mass
print "centering stars"
stars.move_to_center()
print "scaling stars to virial equilibrium"
stars.scale_to_standard(smoothing_length_squared
= gravity.parameters.epsilon_squared)
else:
# Read the input data. Units are dynamical (sorry).
# Format: id mass pos[3] vel[3]
print "reading file", infile
id = []
mass = []
pos = []
vel = []
f = open(infile, 'r')
count = 0
for line in f:
if len(line) > 0:
count += 1
cols = line.split()
if count == 1: snap = int(cols[0])
elif count == 2: number_of_stars = int(cols[0])
elif count == 3: time = float(cols[0]) | nbody_system.time
else:
if len(cols) >= 8:
id.append(int(cols[0]))
mass.append(float(cols[1]))
pos.append((float(cols[2]),
float(cols[3]), float(cols[4])))
vel.append((float(cols[5]),
float(cols[6]), float(cols[7])))
f.close()
stars = datamodel.Particles(number_of_stars)
stars.id = id
stars.mass = mass | nbody_system.mass
stars.position = pos | nbody_system.length
stars.velocity = vel | nbody_system.speed
#stars.radius = 0. | nbody_system.length
total_mass = stars.mass.sum()
ke = pa.kinetic_energy(stars)
kT = ke/(1.5*number_of_stars)
if number_of_binaries > 0:
# Turn selected stars into binary components.
# Only tested for equal-mass case.
kep = Kepler(redirection = "none")
kep.initialize_code()
added_mass = 0.0 | nbody_system.mass
# Work with energies rather than semimajor axes.
Emin = 10*kT
Emax = 20*kT
ecc = 0.1
id_count = number_of_stars
nbin = 0
for i in range(0, number_of_stars,
number_of_stars/number_of_binaries):
# Star i is CM, becomes component, add other star at end.
nbin += 1
mass = stars[i].mass
new_mass = numpy.random.uniform()*mass # uniform q?
mbin = mass + new_mass
fac = new_mass/mbin
E = Emin + numpy.random.uniform()*(Emax-Emin)
a = 0.5*nbody_system.G*mass*new_mass/E
kep.initialize_from_elements(mbin, a, ecc)
dr = quantities.AdaptingVectorQuantity()
dr.extend(kep.get_separation_vector())
dv = quantities.AdaptingVectorQuantity()
dv.extend(kep.get_velocity_vector())
newstar = datamodel.Particles(1)
newstar.mass = new_mass
newstar.position = stars[i].position + (1-fac)*dr
newstar.velocity = stars[i].velocity + (1-fac)*dv
# stars[i].mass = mass
stars[i].position = stars[i].position - fac*dr
stars[i].velocity = stars[i].velocity - fac*dv
id_count += 1
newstar.id = id_count
stars.add_particles(newstar)
added_mass += new_mass
if nbin >= number_of_binaries: break
kep.stop()
print 'created', nbin, 'binaries'
sys.stdout.flush()
stars.mass = stars.mass * total_mass/(total_mass+added_mass)
number_of_stars += nbin
# Set dynamical radii (assuming virial equilibrium and standard
# units). Note that this choice should be refined, and updated
# as the system evolves. Probably the choice of radius should be
# made entirely in the multiples module. TODO. In these units,
# M = 1 and <v^2> = 0.5, so the mean 90-degree turnaround impact
# parameter is
#
# b_90 = G (m_1+m_2) / vrel^2
# = 2 <m> / 2<v^2>
# = 2 / N for equal masses
#
# Taking r_i = m_i / 2<v^2> = m_i in virial equilibrium means
# that, approximately, "contact" means a 90-degree deflection (r_1
# + r_2 = b_90). A more conservative choice with r_i less than
# this value will isolates encounters better, but also place more
# load on the large-N dynamical module.
stars.radius = stars.mass.number | nbody_system.length
time = 0.0 | nbody_system.time
# print "IDs:", stars.id.number
print "recentering stars"
stars.move_to_center()
sys.stdout.flush()
#-----------------------------------------------------------------
if softening_length < 0.0 | nbody_system.length:
# Use ~interparticle spacing. Assuming standard units here. TODO
eps2 = 0.25*(float(number_of_stars))**(-0.666667) \
| nbody_system.length**2
else:
eps2 = softening_length*softening_length
print 'softening length =', eps2.sqrt()
gravity.parameters.timestep_parameter = accuracy_parameter
gravity.parameters.epsilon_squared = eps2
gravity.parameters.use_gpu = use_gpu
# gravity.parameters.manage_encounters = manage_encounters
print ''
print "adding particles"
# print stars
sys.stdout.flush()
gravity.particles.add_particles(stars)
gravity.commit_particles()
print ''
print "number_of_stars =", number_of_stars
print "evolving to time =", end_time.number, \
"in steps of", delta_t.number
sys.stdout.flush()
# Channel to copy values from the code to the set in memory.
channel = gravity.particles.new_channel_to(stars)
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
# Debugging: prevent the multiples code from being called.
if 0:
stopping_condition.disable()
print 'stopping condition disabled'
sys.stdout.flush()
# -----------------------------------------------------------------
# Create the coupled code and integrate the system to the desired
# time, managing interactions internally.
kep = init_kepler(stars[0], stars[1])
multiples_code = multiples.Multiples(gravity, new_smalln, kep)
multiples_code.neighbor_perturbation_limit = 0.1
#multiples_code.neighbor_distance_factor = 1.0
#multiples_code.neighbor_veto = False
#multiples_code.neighbor_distance_factor = 2.0
multiples_code.neighbor_veto = True
print ''
print 'multiples_code.initial_scale_factor =', \
multiples_code.initial_scale_factor
print 'multiples_code.neighbor_perturbation_limit =', \
multiples_code.neighbor_perturbation_limit
print 'multiples_code.neighbor_veto =', \
multiples_code.neighbor_veto
print 'multiples_code.final_scale_factor =', \
multiples_code.final_scale_factor
print 'multiples_code.initial_scatter_factor =', \
multiples_code.initial_scatter_factor
print 'multiples_code.final_scatter_factor =', \
multiples_code.final_scatter_factor
print 'multiples_code.retain_binary_apocenter =', \
multiples_code.retain_binary_apocenter
print 'multiples_code.wide_perturbation_limit =', \
multiples_code.wide_perturbation_limit
pre = "%%% "
E0,cpu0 = print_log(pre, time, multiples_code)
while time < end_time:
time += delta_t
multiples_code.evolve_model(time)
# Copy values from the module to the set in memory.
channel.copy()
# Copy the index (ID) as used in the module to the id field in
# memory. The index is not copied by default, as different
# codes may have different indices for the same particle and
# we don't want to overwrite silently.
channel.copy_attribute("index_in_code", "id")
print_log(pre, time, multiples_code, E0, cpu0)
sys.stdout.flush()
#-----------------------------------------------------------------
if not outfile == None:
# Write data to a file.
f = open(outfile, 'w')
#--------------------------------------------------
# Need to save top-level stellar data and parameters.
# Need to save multiple data and parameters.
f.write('%.15g\n'%(time.number))
for s in multiples_code.stars: write_star(s, f)
#--------------------------------------------------
f.close()
print 'wrote file', outfile
print ''
gravity.stop()
def run_ph4(infile=None,
number_of_stars=40,
end_time=10 | nbody_system.time,
delta_t=1 | nbody_system.time,
n_workers=1,
use_gpu=1,
gpu_worker=1,
accuracy_parameter=0.1,
softening_length=-1 | nbody_system.length,
manage_encounters=1,
random_seed=1234):
if random_seed <= 0:
numpy.random.seed()
random_seed = numpy.random.randint(1, pow(2, 31) - 1)
numpy.random.seed(random_seed)
print("random seed =", random_seed)
if infile != None: print("input file =", infile)
print("end_time =", end_time.number)
print("delta_t =", delta_t.number)
print("n_workers =", n_workers)
print("use_gpu =", use_gpu)
print("manage_encounters =", manage_encounters)
print("\ninitializing the gravity module")
sys.stdout.flush()
# Note that there are actually three GPU options to test:
#
# 1. use the GPU code and allow GPU use (default)
# 2. use the GPU code but disable GPU use (-g)
# 3. use the non-GPU code (-G)
if gpu_worker == 1:
try:
gravity = grav(number_of_workers=n_workers,
redirection="none",
mode="gpu")
except Exception as ex:
gravity = grav(number_of_workers=n_workers, redirection="none")
else:
gravity = grav(number_of_workers=n_workers, redirection="none")
gravity.initialize_code()
gravity.parameters.set_defaults()
#-----------------------------------------------------------------
if infile == None:
print("making a Plummer model")
stars = new_plummer_model(number_of_stars)
id = numpy.arange(number_of_stars)
stars.id = id + 1
print("setting particle masses and radii")
#stars.mass = (1.0 / number_of_stars) | nbody_system.mass
scaled_mass = new_salpeter_mass_distribution_nbody(number_of_stars)
stars.mass = scaled_mass
stars.radius = 0.02 | nbody_system.length
print("centering stars")
stars.move_to_center()
print("scaling stars to virial equilibrium")
stars.scale_to_standard(
smoothing_length_squared=gravity.parameters.epsilon_squared)
time = 0.0 | nbody_system.time
sys.stdout.flush()
else:
# Read the input data. Units are dynamical.
print("reading file", infile)
id = []
mass = []
pos = []
vel = []
f = open(infile, 'r')
count = 0
for line in f:
if len(line) > 0:
count += 1
cols = line.split()
if count == 1: snap = int(cols[0])
elif count == 2: number_of_stars = int(cols[0])
elif count == 3: time = float(cols[0]) | nbody_system.time
else:
if len(cols) >= 8:
id.append(int(cols[0]))
mass.append(float(cols[1]))
pos.append(
(float(cols[2]), float(cols[3]), float(cols[4])))
vel.append(
(float(cols[5]), float(cols[6]), float(cols[7])))
f.close()
stars = datamodel.Particles(number_of_stars)
stars.id = id
stars.mass = mass | nbody_system.mass
stars.position = pos | nbody_system.length
stars.velocity = vel | nbody_system.speed
stars.radius = 0. | nbody_system.length
# print "IDs:", stars.id.number
sys.stdout.flush()
#-----------------------------------------------------------------
if softening_length == -1 | nbody_system.length:
eps2 = 0.25*(float(number_of_stars))**(-0.666667) \
| nbody_system.length**2
else:
eps2 = softening_length * softening_length
gravity.parameters.timestep_parameter = accuracy_parameter
gravity.parameters.epsilon_squared = eps2
gravity.parameters.use_gpu = use_gpu
# gravity.parameters.manage_encounters = manage_encounters
print("adding particles")
# print stars
sys.stdout.flush()
gravity.particles.add_particles(stars)
gravity.commit_particles()
print('')
print("number_of_stars =", number_of_stars)
print("evolving to time =", end_time.number, \
"in steps of", delta_t.number)
sys.stdout.flush()
E0 = print_log(time, gravity)
# Channel to copy values from the code to the set in memory.
channel = gravity.particles.new_channel_to(stars)
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
kep = Kepler(redirection="none")
kep.initialize_code()
multiples_code = multiples.Multiples(gravity, new_smalln, kep)
while time < end_time:
time += delta_t
multiples_code.evolve_model(time)
# Copy values from the module to the set in memory.
channel.copy()
# Copy the index (ID) as used in the module to the id field in
# memory. The index is not copied by default, as different
# codes may have different indices for the same particle and
# we don't want to overwrite silently.
channel.copy_attribute("index_in_code", "id")
print_log(time, gravity, E0)
sys.stdout.flush()
print('')
gravity.stop()
def make_nbody(number_of_stars=100,
time=0.0,
n_workers=1,
use_gpu=1,
gpu_worker=1,
salpeter=0,
delta_t=1.0 | nbody_system.time,
timestep_parameter=0.1,
softening_length=0.0 | nbody_system.length,
random_seed=1234):
# Make an N-body system, print out some statistics on it, and save
# it in a restart file. The restart file name is of the form
# 't=nnnn.n.xxx', where the default time is 0.0.
if random_seed <= 0:
numpy.random.seed()
random_seed = numpy.random.randint(1, pow(2, 31) - 1)
numpy.random.seed(random_seed)
print "random seed =", random_seed
init_smalln()
# Note that there are actually three GPU options:
#
# 1. use the GPU code and allow GPU use (default)
# 2. use the GPU code but disable GPU use (-g)
# 3. use the non-GPU code (-G)
if gpu_worker == 1:
try:
gravity = grav(number_of_workers=n_workers,
redirection="none",
mode="gpu")
except Exception as ex:
gravity = grav(number_of_workers=n_workers, redirection="none")
else:
gravity = grav(number_of_workers=n_workers, redirection="none")
gravity.initialize_code()
gravity.parameters.set_defaults()
#-----------------------------------------------------------------
# Make a standard N-body system.
print "making a Plummer model"
stars = new_plummer_model(number_of_stars)
id = numpy.arange(number_of_stars)
stars.id = id + 1
print "setting particle masses and radii"
if salpeter == 0:
print 'equal masses'
total_mass = 1.0 | nbody_system.mass
scaled_mass = total_mass / number_of_stars
else:
print 'salpeter mass function'
mmin = 0.5 | nbody_system.mass
mmax = 10.0 | nbody_system.mass
scaled_mass = new_salpeter_mass_distribution_nbody(number_of_stars,
mass_min=mmin,
mass_max=mmax)
stars.mass = scaled_mass
print "centering stars"
stars.move_to_center()
print "scaling stars to virial equilibrium"
stars.scale_to_standard(
smoothing_length_squared=gravity.parameters.epsilon_squared)
# Set dynamical radii (assuming virial equilibrium and standard
# units). Note that this choice should be refined, and updated
# as the system evolves. Probably the choice of radius should be
# made entirely in the multiples module. TODO. In these units,
# M = 1 and <v^2> = 0.5, so the mean 90-degree turnaround impact
# parameter is
#
# b_90 = G (m_1+m_2) / vrel^2
# = 2 <m> / 2<v^2>
# = 2 / N for equal masses
#
# Taking r_i = m_i / 2<v^2> = m_i in virial equilibrium means
# that, approximately, "contact" means a 90-degree deflection (r_1
# + r_2 = b_90). A more conservative choice with r_i less than
# this value will isolate encounters better, but also place more
# load on the large-N dynamical module.
stars.radius = 0.5 * stars.mass.number | nbody_system.length
time = 0.0 | nbody_system.time
# print "IDs:", stars.id.number
print "recentering stars"
stars.move_to_center()
sys.stdout.flush()
#-----------------------------------------------------------------
if softening_length < 0.0 | nbody_system.length:
# Use ~interparticle spacing. Assuming standard units here. TODO
softening_length = 0.5*float(number_of_stars)**(-0.3333333) \
| nbody_system.length
print 'softening length =', softening_length
gravity.parameters.timestep_parameter = timestep_parameter
gravity.parameters.epsilon_squared = softening_length * softening_length
gravity.parameters.use_gpu = use_gpu
print ''
print "adding particles"
# print stars
sys.stdout.flush()
gravity.particles.add_particles(stars)
gravity.commit_particles()
print ''
print "number_of_stars =", number_of_stars
sys.stdout.flush()
# Channel to copy values from the code to the set in memory.
channel = gravity.particles.new_channel_to(stars)
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
# -----------------------------------------------------------------
# Create the coupled code and integrate the system to the desired
# time, managing interactions internally.
kep = init_kepler(stars[0], stars[1])
multiples_code = multiples.Multiples(gravity, new_smalln, kep)
multiples_code.neighbor_perturbation_limit = 0.1
multiples_code.neighbor_veto = True
print ''
print 'multiples_code.initial_scale_factor =', \
multiples_code.initial_scale_factor
print 'multiples_code.neighbor_perturbation_limit =', \
multiples_code.neighbor_perturbation_limit
print 'multiples_code.neighbor_veto =', \
multiples_code.neighbor_veto
print 'multiples_code.final_scale_factor =', \
multiples_code.final_scale_factor
print 'multiples_code.initial_scatter_factor =', \
multiples_code.initial_scatter_factor
print 'multiples_code.final_scatter_factor =', \
multiples_code.final_scatter_factor
print 'multiples_code.retain_binary_apocenter =', \
multiples_code.retain_binary_apocenter
print 'multiples_code.wide_perturbation_limit =', \
multiples_code.wide_perturbation_limit
# Take a dummy step, just in case...
multiples_code.evolve_model(time)
# Copy values from the module to the set in memory.
channel.copy()
# Copy the index (ID) as used in the module to the id field in
# memory. The index is not copied by default, as different
# codes may have different indices for the same particle and
# we don't want to overwrite silently.
channel.copy_attribute("index_in_code", "id")
pre = "%%% "
E0, cpu0 = print_log(pre, time, multiples_code)
sys.stdout.flush()
# file = 't='+'{:07.2f}'.format(time.number) # fails in Python 2.6
file = 't=%07.2f' % time.number
write_state_to_file(time, stars, gravity, multiples_code, file, delta_t,
E0, cpu0)
tree_copy = multiples_code.root_to_tree.copy()
del multiples_code
sys.stdout.flush()
gravity.stop()
kep.stop()
stop_smalln()
print ''
def run_ph4(options,
time=None,
stars=None,
mc_root_to_tree=None,
randomize=True):
infile = options.infile
outfile = options.outfile
restart_file = options.restart_file
number_of_stars = options.N
number_of_binaries = options.Nbin
end_time = options.t_end | nbody_system.time
delta_t = options.delta_t | nbody_system.time
n_workers = options.n_workers
use_gpu = options.use_gpu
gpu_worker = options.gpu_worker
salpeter = options.salpeter
accuracy_parameter = options.accuracy_parameter
softening_length = options.softening_length | nbody_system.length
manage_encounters = options.manage_encounters
random_seed = options.random_seed
if randomize:
if random_seed <= 0:
numpy.random.seed()
random_seed = numpy.random.randint(1, pow(2, 31) - 1)
numpy.random.seed(random_seed)
print "random seed =", random_seed
if infile is not None: print "input file =", infile
if restart_file is not None: print "restart file =", restart_file
if restart_file is not None and infile is not None:
print "restart file overrides input file"
print "end_time =", end_time.number
print "delta_t =", delta_t.number
print "n_workers =", n_workers
print "use_gpu =", use_gpu
print "manage_encounters =", manage_encounters
print "n =", number_of_stars
print "nbin=", number_of_binaries
print "\ninitializing the gravity module"
sys.stdout.flush()
init_smalln()
# Note that there are actually three GPU options:
#
# 1. use the GPU code and allow GPU use (default)
# 2. use the GPU code but disable GPU use (-g)
# 3. use the non-GPU code (-G)
if gpu_worker == 1:
try:
#gravity = GravityModule(number_of_workers = n_workers,
# redirection = "xterm")
gravity = GravityModule(number_of_workers=n_workers,
redirection="none",
mode="gpu")
except Exception as ex:
gravity = GravityModule(number_of_workers=n_workers,
redirection="none")
else:
gravity = GravityModule(number_of_workers=n_workers,
redirection="none")
gravity.initialize_code()
gravity.parameters.set_defaults()
if softening_length < 0.0 | nbody_system.length:
# Use ~interparticle spacing. Assuming standard units here. TODO
eps2 = 0.25*(float(number_of_stars))**(-0.666667) \
| nbody_system.length**2
else:
eps2 = softening_length * softening_length
print 'softening length =', eps2.sqrt()
gravity.parameters.timestep_parameter = accuracy_parameter
gravity.parameters.epsilon_squared = eps2
gravity.parameters.use_gpu = use_gpu
kep = Kepler(redirection="none")
kep.initialize_code()
multiples_code = None
Xtra = numpy.zeros(2)
#-----------------------------------------------------------------
if (restart_file is None
or not os.path.exists(restart_file + ".stars.hdf5")
) and infile is None and stars is None:
print "making a Plummer model"
stars = new_plummer_model(number_of_stars)
id = numpy.arange(number_of_stars)
stars.id = id + 1
print "setting particle masses and radii"
if salpeter == 0:
print 'equal masses'
total_mass = 1.0 | nbody_system.mass
scaled_mass = total_mass / number_of_stars
else:
print 'salpeter mass function'
scaled_mass = new_salpeter_mass_distribution_nbody(number_of_stars)
stars.mass = scaled_mass
print "centering stars"
stars.move_to_center()
print "scaling stars to virial equilibrium"
stars.scale_to_standard(
smoothing_length_squared=gravity.parameters.epsilon_squared)
time = 0.0 | nbody_system.time
total_mass = stars.mass.sum()
ke = pa.kinetic_energy(stars)
kT = ke / (1.5 * number_of_stars)
# Set dynamical radii (assuming virial equilibrium and standard
# units). Note that this choice should be refined, and updated
# as the system evolves. Probably the choice of radius should be
# made entirely in the multiples module. TODO. In these units,
# M = 1 and <v^2> = 0.5, so the mean 90-degree turnaround impact
# parameter is
#
# b_90 = G (m_1+m_2) / vrel^2
# = 2 <m> / 2<v^2>
# = 2 / N for equal masses
#
# Taking r_i = m_i / 2<v^2> = m_i in virial equilibrium means
# that, approximately, "contact" means a 90-degree deflection (r_1
# + r_2 = b_90). A more conservative choice with r_i less than
# this value will isolates encounters better, but also place more
# load on the large-N dynamical module.
stars.radius = stars.mass.number | nbody_system.length
if number_of_binaries > 0:
# Turn selected stars into binary components.
# Only tested for equal-mass case.
added_mass = 0.0 | nbody_system.mass
# Work with energies rather than semimajor axes.
Emin = 10 * kT
Emax = 20 * kT
ecc = 0.1
id_count = number_of_stars
nbin = 0
for i in range(0, number_of_stars,
number_of_stars / number_of_binaries):
# Star i is CM, becomes component, add other star at end.
nbin += 1
mass = stars[i].mass
#new_mass = numpy.random.uniform()*mass # uniform q?
new_mass = mass # uniform q?
mbin = mass + new_mass
fac = new_mass / mbin
E = Emin + numpy.random.uniform() * (Emax - Emin)
a = 0.5 * nbody_system.G * mass * new_mass / E
kep.initialize_from_elements(mbin, a, ecc)
dr = quantities.AdaptingVectorQuantity()
dr.extend(kep.get_separation_vector())
dv = quantities.AdaptingVectorQuantity()
dv.extend(kep.get_velocity_vector())
newstar = datamodel.Particles(1)
newstar.mass = new_mass
newstar.position = stars[i].position + (1 - fac) * dr
newstar.velocity = stars[i].velocity + (1 - fac) * dv
newstar.radius = newstar.mass.number | nbody_system.length
#newstar.radius = 3.0*stars[i].radius # HACK: try to force collision
# stars[i].mass = mass
stars[i].position = stars[i].position - fac * dr
stars[i].velocity = stars[i].velocity - fac * dv
id_count += 1
newstar.id = id_count
stars.add_particles(newstar)
added_mass += new_mass
if nbin >= number_of_binaries: break
kep.stop()
print 'created', nbin, 'binaries'
sys.stdout.flush()
stars.mass = stars.mass * total_mass / (total_mass + added_mass)
number_of_stars += nbin
Xtra = numpy.zeros(2)
print "recentering stars"
stars.move_to_center()
sys.stdout.flush()
stars.savepoint(time)
print ''
print "adding particles"
# print stars
sys.stdout.flush()
gravity.particles.add_particles(stars)
gravity.commit_particles()
else:
print "Restart detected. Loading parameters from restart."
new_end = options.t_end
stars, time, multiples_code, Xtra = MRest.read_state_from_file(
restart_file, gravity, new_smalln, kep)
options.t_end = new_end
total_mass = stars.mass.sum()
ke = pa.kinetic_energy(stars)
kT = ke / (1.5 * number_of_stars)
# print "IDs:", stars.id.number
print ''
print "number_of_stars =", number_of_stars
print "evolving to time =", end_time.number, \
"in steps of", delta_t.number
sys.stdout.flush()
# Channel to copy values from the code to the set in memory.
channel = gravity.particles.new_channel_to(stars)
stopping_condition = gravity.stopping_conditions.collision_detection
stopping_condition.enable()
# -----------------------------------------------------------------
# Create the coupled code and integrate the system to the desired
# time, managing interactions internally.
kep = init_kepler(stars[0], stars[1])
if not multiples_code:
multiples_code = multiples.Multiples(gravity, new_smalln, kep)
multiples_code.neighbor_distance_factor = 1.0
multiples_code.neighbor_veto = True
#multiples_code.neighbor_distance_factor = 2.0
#multiples_code.neighbor_veto = True
multiples_code.retain_binary_apocenter = False
print ''
print 'multiples_code.initial_scale_factor =', \
multiples_code.initial_scale_factor
print 'multiples_code.neighbor_distance_factor =', \
multiples_code.neighbor_distance_factor
print 'multiples_code.neighbor_veto =', \
multiples_code.neighbor_veto
print 'multiples_code.final_scale_factor =', \
multiples_code.final_scale_factor
print 'multiples_code.initial_scatter_factor =', \
multiples_code.initial_scatter_factor
print 'multiples_code.final_scatter_factor =', \
multiples_code.final_scatter_factor
print 'multiples_code.retain_binary_apocenter =', \
multiples_code.retain_binary_apocenter
# if mc_root_to_tree is not None:
# multiples_code.root_to_tree = mc_root_to_tree
# print 'multiples code re-loaded with binary trees snapshot'
pre = "%%% "
E0, cpu0 = print_log(pre, time, multiples_code)
while time < end_time:
time += delta_t
multiples_code.evolve_model(time)
# Copy values from the module to the set in memory.
channel.copy()
# Copy the index (ID) as used in the module to the id field in
# memory. The index is not copied by default, as different
# codes may have different indices for the same particle and
# we don't want to overwrite silently.
channel.copy_attribute("index_in_code", "id")
print_log(pre, time, multiples_code, E0, cpu0)
stars.savepoint(time)
MRest.write_state_to_file(time,
stars,
gravity,
multiples_code,
options.restart_file,
Xtra,
backup=1)
sys.stdout.flush()
#-----------------------------------------------------------------
if not outfile is None:
# Write data to a file.
f = open(outfile, 'w')
#--------------------------------------------------
# Need to save top-level stellar data and parameters.
# Need to save multiple data and parameters.
f.write('%.15g\n' % time.number)
for s in multiples_code.stars:
write_star(s, f)
#--------------------------------------------------
f.close()
print 'wrote file', outfile
print ''
gravity.stop()
