def new_instance_of_fi_code(self):
result=Fi(self.convert_nbody_units, number_of_workers=self.number_of_workers,
mode = "periodic", **self.hydro_code_options)
result.initialize_code()
result.parameters.self_gravity_flag = False
result.parameters.timestep = 0.01 | time
return result
def bb79_cloud_evolve(N=50000,
Mcloud=1. | units.MSun,
Rcloud=3.2e16 | units.cm,
omega=1.56e-12 | units.rad/units.s,
density_perturb=0.5,
t_total=8.3e11 | units.s):
# mean density of the cloud
rho_uni = Mcloud / (4./3.*numpy.pi*Rcloud**3)
print(" ** mean density = ", rho_uni.in_(units.g/units.cm**3))
# free fall time of the cloud
t_ff = numpy.sqrt(3.*numpy.pi / (32.*units.constants.G*rho_uni))
print(" ** free-fall time = ", t_ff.in_(units.yr))
conv = nbody_system.nbody_to_si(Mcloud, Rcloud)
sph = Fi(conv)
# the initial conditions of BB79
parts_bb79 = bb79_cloud(targetN=N, omega=omega, rho_perturb=0.5,
ethep_ratio=0.25, convert_nbody=conv,
base_grid=body_centered_grid_unit_cube).result
sph.gas_particles.add_particles(parts_bb79)
sph.parameters.use_hydro_flag = True
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.gamma = 1
sph.parameters.verbosity = 0
sph.parameters.timestep = 0.1*t_ff
print(
"**evolving to time: (end time = ~ {0:.3f} t_ff)".format(t_total/t_ff))
# setting snapshots to be plotted
nplot = 10
if nplot > 1:
plot_timestep = t_total / (nplot - 1)
else:
plot_timestep = t_total
# evolution of the cloud
for i in range(nplot):
ttarget = i*plot_timestep
t_tff = ttarget / t_ff
sph.evolve_model(ttarget)
plot_i = "bb79_rho_{0:03d}.png".format(i)
tt_tff = "{0:.3f}".format(t_tff)
title_i = "$%s\,t_{\mathrm{ff}}$" % (tt_tff)
print("\t {0:.3f} t_ff -> {1}".format(t_tff, plot_i))
plot_sph_rho(sph, N=300, grid_size=0.025 | units.parsec,
plot_name=plot_i, plot_title=title_i)
sph.stop()
def new_instance_of_fi_code(self):
result = Fi(self.convert_nbody_units,
number_of_workers=self.number_of_workers,
mode="periodic",
**self.hydro_code_options)
result.initialize_code()
result.parameters.self_gravity_flag = False
result.parameters.timestep = 0.01 | time
return result
def new_star_code_fi(self):
result = Fi(self.converter)
result.parameters.self_gravity_flag = True
result.parameters.use_hydro_flag = False
result.parameters.radiation_flag = False
result.parameters.periodic_box_size = 500 | units.parsec
result.parameters.timestep = 0.125 * self.interaction_timestep
result.particles.add_particles(self.new_particles_cluster())
result.commit_particles()
return result
def new_star_code_fi(self):
result = Fi()
result.parameters.self_gravity_flag = True
result.parameters.use_hydro_flag = False
result.parameters.radiation_flag = False
result.parameters.periodic_box_size = 500 | units.parsec
result.parameters.timestep = 0.125 * self.interaction_timestep
result.particles.add_particles(self.new_particles_cluster())
result.commit_particles()
return result
def new_gas_code_fi(self):
result = Fi(self.converter)
result.parameters.self_gravity_flag = True
result.parameters.use_hydro_flag = True
result.parameters.radiation_flag = False
result.parameters.periodic_box_size = 500 | units.parsec
result.parameters.timestep = 0.125 * self.interaction_timestep
# result.parameters.adaptive_smoothing_flag = True
# result.parameters.epsilon_squared = self.gas_epsilon ** 2
# result.parameters.eps_is_h_flag = False
result.parameters.integrate_entropy_flag = False
# result.parameters.self_gravity_flag = False
result.gas_particles.add_particles(self.new_gas_cluster())
result.commit_particles()
return result
def new_gas_code_fi(self):
result = Fi(self.converter)
result.parameters.self_gravity_flag = True
result.parameters.use_hydro_flag = True
result.parameters.radiation_flag = False
result.parameters.periodic_box_size = 500 | units.parsec
result.parameters.timestep = 0.125 * self.interaction_timestep
#result.parameters.adaptive_smoothing_flag = True
#result.parameters.epsilon_squared = self.gas_epsilon ** 2
#result.parameters.eps_is_h_flag = False
result.parameters.integrate_entropy_flag = False
#result.parameters.self_gravity_flag = False
result.gas_particles.add_particles(self.new_gas_cluster())
result.commit_particles()
return result
def new_hydro(gas, converter, time_step, distributed):
if distributed is None:
# distributed_kwargs = dict(number_of_workers=24, label="hydro")
distributed_kwargs = dict(number_of_workers=16)
else:
# distributed_kwargs = dict(label="local", number_of_workers=6, number_of_nodes=1)
distributed_kwargs = dict(label="hydro", number_of_workers=16, number_of_nodes=1)
if "cartesius" in distributed.resources.name:
distributed.pilots.add_pilot(new_cartesius_pilot())
print "Waiting for Cartesius reservation"
distributed.wait_for_pilots()
print "Start hydro"
if True:
hydro = Gadget2(
converter,
redirection="file",
redirect_file="gas_code.log",
**distributed_kwargs)
# hydro.parameters.n_smooth = 64
# hydro.parameters.n_smooth_tol = 0.005 |units.none
hydro.parameters.time_max = 32.0 | units.Myr
hydro.parameters.max_size_timestep = time_step
hydro.parameters.time_limit_cpu = 1.0 | units.yr
else:
distributed_kwargs['number_of_threads'] = distributed_kwargs['number_of_workers']
distributed_kwargs['number_of_workers'] = 1
print distributed_kwargs
hydro = Fi(
converter, mode='openmp',
redirection="file",
redirect_file="gas_code.log",
**distributed_kwargs)
hydro.parameters.eps_is_h_flag = True
hydro.parameters.timestep = time_step
hydro.parameters.verbosity = 99
hydro.gas_particles.add_particles(gas)
hydro.commit_particles()
eps = hydro.gas_particles.radius.as_quantity_in(units.parsec)
print "Gravitational softening for gas (mean, min, max):", eps.mean(), eps.min(), eps.max()
return hydro
def new_hydro(gas, dynamical_timescale, converter):
if False:
hydro = Gadget2(converter, number_of_workers=8, redirection="file", redirect_file="gadget.log")
hydro.parameters.time_max = 3 * dynamical_timescale
hydro.parameters.max_size_timestep = dynamical_timescale / 100
hydro.parameters.time_limit_cpu = 1.0 | units.Gyr
else:
hydro = Fi(converter, mode='openmp', redirection="file", redirect_file="fi.log")
hydro.parameters.timestep = dynamical_timescale / 100
hydro.parameters.eps_is_h_flag = True
return hydro
def main(t_end=1000. | units.yr, dt=10. | units.yr):
print 'Initializing...'
converter = nbody_system.nbody_to_si(1. | units.MSun, 1. | units.AU)
# Initialize the gravity system
Sun_and_Jupiter = init_sun_jupiter()
Sun = Sun_and_Jupiter[0]
Jupiter = Sun_and_Jupiter[1]
orbit0 = orbital_elements_from_binary(Sun_and_Jupiter, G=constants.G)
a0 = orbit0[2].in_(units.AU)
e0 = orbit0[3]
Hill_radius0 = a0 * (1 - e0) * (
(1.0 | units.MJupiter).value_in(units.MSun) / 3.)**(1. / 3.)
# Initialising the direct N-body integrator
gravity = ph4(converter)
gravity.particles.add_particle(Jupiter)
gravity.timestep = dt
# Setting proto-disk parameters
N = 4000
Mstar = 1. | units.MSun
Mdisk = 0.01 * Mstar
Rmin = 2.
Rmax = 100.
# Initialising the proto-planetary disk
np.random.seed(1)
disk = ProtoPlanetaryDisk(N,
convert_nbody=converter,
densitypower=1.5,
Rmin=Rmin,
Rmax=Rmax,
q_out=1.,
discfraction=Mdisk / Mstar)
disk_gas = disk.result
# Initialize the sink particle
sink = init_sink_particle(0. | units.MSun, Hill_radius0, Jupiter.position,
Jupiter.velocity)
# Initialising the SPH code
sph = Fi(converter, mode="openmp")
sph.gas_particles.add_particles(disk_gas)
sph.dm_particles.add_particle(Sun)
sph.parameters.timestep = dt
# bridge and evolve
a_Jup, e_Jup, disk_size, times, accreted_mass = gravity_hydro_bridge(
gravity, sph, sink, [Sun_and_Jupiter, disk_gas], Rmin, t_end, dt)
return a_Jup, e_Jup, disk_size, times, accreted_mass
def main(t_end=1000. | units.yr, dt=10. | units.yr):
print 'Initializing...'
converter = nbody_system.nbody_to_si(1. | units.MSun, 1. | units.AU)
# Initialize the gravity system
Sun_and_Jupiter = init_sun_jupiter()
Sun = Sun_and_Jupiter[0]
Jupiter = Sun_and_Jupiter[1]
orbit0 = orbital_elements_from_binary(Sun_and_Jupiter, G=constants.G)
a0 = orbit0[2].in_(units.AU)
e0 = orbit0[3]
Hill_radius0 = a0 * (1 - e0) * (
(1.0 | units.MJupiter).value_in(units.MSun) / 3.)**(1. / 3.)
gravity = ph4(converter)
gravity.particles.add_particles(Sun_and_Jupiter)
gravity.timestep = dt
# initialize the hydrodynamics(SPH) system
# initialize the protoplanetary disk
N = 1000
Mstar = 1. | units.MSun
Mdisk = 0.01 * Mstar
Rmin = 2.
Rmax = 100.
np.random.seed(1)
disk = ProtoPlanetaryDisk(N,
convert_nbody=converter,
densitypower=1.5,
Rmin=Rmin,
Rmax=Rmax,
q_out=1.)
disk_gas = disk.result
disk_gas.h_smooth = 0.06 | units.AU
# initialize the sink particle
sink = init_sink_particle(0. | units.MSun, Hill_radius0, Jupiter.position,
Jupiter.velocity)
sph = Fi(converter)
sph.particles.add_particles(sink)
sph.gas_particles.add_particles(disk_gas)
sph.parameters.timestep = dt
# bridge and evolve
a_Jup, e_Jup, disk_size, times = gravity_hydro_bridge(gravity, sph, \
[Sun_and_Jupiter, disk_gas], Rmin, t_end, dt)
return a_Jup, e_Jup, disk_size, times
def bb79_cloud_evolve(N=50000,
Mcloud=1. | units.MSun,
Rcloud=3.2e16 | units.cm,
omega=1.56e-12 | units.rad / units.s,
density_perturb=0.5,
t_total=8.3e11 | units.s):
# mean density of the cloud
rho_uni = Mcloud / (4. / 3. * numpy.pi * Rcloud**3)
print(" ** mean density = ", rho_uni.in_(units.g / units.cm**3))
# free fall time of the cloud
t_ff = numpy.sqrt(3. * numpy.pi / (32. * units.constants.G * rho_uni))
print(" ** free-fall time = ", t_ff.in_(units.yr))
conv = nbody_system.nbody_to_si(Mcloud, Rcloud)
sph = Fi(conv)
# the initial conditions of BB79
parts_bb79 = bb79_cloud(targetN=N, omega=omega, rho_perturb=0.5,
ethep_ratio=0.25, convert_nbody=conv,
base_grid=body_centered_grid_unit_cube).result
sph.gas_particles.add_particles(parts_bb79)
sph.parameters.use_hydro_flag = True
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.gamma = 1
sph.parameters.verbosity = 0
sph.parameters.timestep = 0.1 * t_ff
print(
"**evolving to time: (end time = ~ {0:.3f} t_ff)".format(t_total / t_ff))
# setting snapshots to be plotted
nplot = 10
if nplot > 1:
plot_timestep = t_total / (nplot - 1)
else:
plot_timestep = t_total
# evolution of the cloud
for i in range(nplot):
ttarget = i * plot_timestep
t_tff = ttarget / t_ff
sph.evolve_model(ttarget)
plot_i = "bb79_rho_{0:03d}.png".format(i)
tt_tff = "{0:.3f}".format(t_tff)
title_i = "$%s\,t_{\mathrm{ff}}$" % (tt_tff)
print("\t {0:.3f} t_ff -> {1}".format(t_tff, plot_i))
plot_sph_rho(sph, N=300, grid_size=0.025 | units.parsec,
plot_name=plot_i, plot_title=title_i)
sph.stop()
def setup_codes(cluster, gas, nbody_converter, gas_converter):
gravity = BHTree(nbody_converter)
gravity.particles.add_particles(cluster)
hydro = Fi(gas_converter)
hydro.parameters.eps_is_h_flag = True
hydro.parameters.timestep = 0.005 | units.Myr
hydro.particles.add_particles(gas)
bridge = Bridge(timestep=0.01 | units.Myr, use_threading=False)
bridge.add_system(gravity, (hydro, ))
bridge.add_system(hydro, (gravity, ))
channels = Channels()
channels.add_channel(gravity.particles.new_channel_to(cluster))
channels.add_channel(hydro.particles.new_channel_to(gas))
return gravity, hydro, bridge, channels
def iliev_test_5(N=10000, Ns=10, L=15. | units.kpc, dt=None):
"""
prepare iliev test and return SPH and simplex interfaces
"""
gas, sources = iliev_test_5_ic(N, Ns, L)
conv = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
sph = Fi(conv, use_gl=False, mode='periodic', redirection='none')
sph.initialize_code()
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = False
sph.parameters.gamma = 1
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = dt
sph.parameters.verbosity = 0
sph.parameters.pboxsize = 2 * L
sph.commit_parameters()
sph.gas_particles.add_particles(gas)
sph.commit_particles()
# sph.start_viewer()
rad = SimpleX(number_of_workers=1, redirection='none')
rad.initialize_code()
rad.parameters.box_size = 2 * L
rad.parameters.hilbert_order = 0
rad.commit_parameters()
gas.add_particles(sources)
rad.particles.add_particles(gas)
rad.commit_particles()
return sph, rad
def iliev_test_5( N=10000,
Ns=10,
L=15. | units.kpc,
dt=None):
"""
prepare iliev test and return SPH and simplex interfaces
"""
gas,sources=iliev_test_5_ic(N,Ns,L)
conv=nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
sph=Fi(conv,use_gl=False,mode='periodic',redirection='none')
sph.initialize_code()
sph.parameters.use_hydro_flag=True
sph.parameters.radiation_flag=False
sph.parameters.self_gravity_flag=False
sph.parameters.gamma=1
sph.parameters.isothermal_flag=True
sph.parameters.integrate_entropy_flag=False
sph.parameters.timestep=dt
sph.parameters.verbosity=0
sph.parameters.pboxsize=2*L
sph.commit_parameters()
sph.gas_particles.add_particles(gas)
sph.commit_particles()
# sph.start_viewer()
rad=SimpleX(number_of_workers = 1,redirection='none')
rad.initialize_code()
rad.parameters.box_size=2*L
rad.parameters.hilbert_order=0
rad.commit_parameters()
gas.add_particles(sources)
rad.particles.add_particles(gas)
rad.commit_particles()
return sph,rad
def iliev_test_7(N=10000,
Ns=10,
L=6.6 | units.kpc,
dt=1 | units.Myr,
rad_parameters=dict()):
rad_parameters["box_size"] = 2 * L
gas, sources = iliev_test_7_ic(N, Ns, L)
#print (len(gas), len(sources))
conv = nbody_system.nbody_to_si(1.0e9 | units.MSun, 1.0 | units.kpc)
sph = Fi(conv, mode='periodic')
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = False
sph.parameters.gamma = 1
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = dt / 2
sph.parameters.verbosity = 0
sph.parameters.periodic_box_size = 2 * L
sph.gas_particles.add_particles(gas)
print sph.parameters.timestep.in_(units.Myr)
rad = SPHRay(redirection='none') #,debugger='gdb')
for x in rad_parameters:
print x, rad_parameters[x]
rad.parameters.__setattr__(x, rad_parameters[x])
# gas.u=100*gas.u
rad.gas_particles.add_particles(gas)
rad.src_particles.add_particles(sources)
return sph, rad
def init_integrator(method):
if method == 'octgrav':
gravity = Octgrav()
elif method == 'ph4':
gravity = ph4()
elif method == 'fi':
gravity = Fi(convert_nbody)
gravity.initialize_code()
gravity.parameters.epsilon_squared = 0.00000001 | units.AU**2
gravity.parameters.timestep = .10 | units.day
elif method == 'phigrape':
gravity = PhiGRAPE(convert_nbody, mode=PhiGRAPEInterface.MODE_GPU)
elif method == 'bhtree':
gravity = BHTree(convert_nbody, number_of_workes=workers)
elif method == 'hermite':
gravity = Hermite(convert_nbody,
number_of_workers=workers
#debugger = "xterm",
#redirection = "none"
)
gravity.parameters.epsilon_squared = 0.00001 | units.AU**2
return gravity
def evolve(cluster,cloud, converter_grav,converter_sph, t_end, dt_sph, dt_diag,\
sink=True, merge=False):
with open(printout_file, 'a') as pf:
pf.write('Setting up the gravity code and the hydro code...\n')
'''# Initialising the direct N-body integrator
gravity = ph4(converter_grav)
gravity.particles.add_particles(cluster)'''
# Initialising the hydro code
sph = Fi(converter_sph, mode="openmp")
sph.gas_particles.add_particles(cloud)
sph.dm_particles.add_particles(cluster)
sph.parameters.radiation_flag = False
#sph.parameters.isothermal_flag = True
#sph.parameters.integrate_entropy_flag = False #should we consider isothermal process or adiabatic one?
sph.parameters.timestep = dt_sph
#sph.parameters.eps_is_h_flag = False # h_smooth is constant
#eps = 0.1 | units.parsec
#sph.parameters.gas_epsilon = eps
#sph.parameters.sph_h_const = eps
#cloud.h_smooth= eps
'''# Building a bridge between hydro and grav
with open(printout_file, 'a') as pf:
pf.write('Bridging...\n')
grav_sph = bridge.Bridge(use_threading=False)
grav_sph.add_system(gravity, (sph,))
grav_sph.add_system(sph, (gravity,))
grav_sph.timestep = dt_bridge'''
# Setting up channels from code to cloud and cluster
#channel_from_grav_to_cluster = gravity.particles.new_channel_to(cluster)
channel_from_sph_to_cloud = sph.gas_particles.new_channel_to(cloud)
channel_from_sph_to_cluster = sph.dm_particles.new_channel_to(cluster)
# consider star formation
if sink == True:
with open(printout_file, 'a') as pf:
pf.write('[Star formation is considered.]\n')
stars = Particles(0)
sph.dm_particles.add_particles(stars)
density_threshold = Jeans_density(M=sph.gas_particles.mass.max())
sph.parameters.stopping_condition_maximum_density = density_threshold
density_limit_detection = sph.stopping_conditions.density_limit_detection
density_limit_detection.enable()
if merge == True:
merge_radius = 1e-4 | units.parsec # 1 pc = 206265 AU
with open(printout_file, 'a') as pf:
pf.write('[Star merging is considered.]\n')
# Initialize data lists (Lagrangian radii and relative total energy)
lr_cloud_list = [Lagrange_radii(cloud, converter_sph)]
lr_cluster_list = [Lagrange_radii(cluster, converter_grav)]
E0_cloud = get_energy(cloud)
Etot0_cloud = E0_cloud[-1]
E_cloud_list = [E0_cloud / Etot0_cloud]
E0_cluster = get_energy(cluster)
Etot0_cluster = E0_cluster[-1]
E_cluster_list = [E0_cluster / Etot0_cluster]
n_formed_star = [0]
# Start Evolving!
# unify the unit of times
unit_time = units.Myr
t_end = t_end.in_(unit_time)
dt_diag = dt_diag.in_(unit_time)
dt_sph = dt_sph.in_(unit_time)
times = quantities.arange(0. | unit_time, t_end + dt_diag, dt_diag)
with open(printout_file, 'a') as pf:
pf.write('\nStart evolving the molecular cloud...\n')
pf.write(
f'End time = {t_end}; Diagnostic timestep = {dt_diag}; sph code timestep = {dt_sph}.\n'
)
for i, t in enumerate(times):
with open(printout_file, 'a') as pf:
pf.write(f'---------- Time = {t.in_(units.Myr)} ----------\n')
# calculate the dynamical(dyn), half-mass relaxation(rh), and free-fall(ff) timescales
# of both the cloud and the cluster systems
t_dyn_cloud, t_rh_cloud, t_ff_cloud = timescale(cloud, unit_time)
t_dyn_cluster, t_rh_cluster, t_ff_cluster = timescale(
cluster, unit_time)
all_timescales = [
t_dyn_cloud, t_rh_cloud, t_ff_cloud, t_dyn_cluster, t_rh_cluster,
t_ff_cluster
] | unit_time
# check if the bridge timestep should be reduced
if all_timescales.amax() < 10 * dt_sph:
dt_sph_old = dt_sph
dt_sph = all_timescales.amax() / 10.
with open(printout_file, 'a') as pf:
pf.write(
f'Change the bridge timestep from {dt_sph_old} to {dt_sph}.\n'
)
if sink == True:
# make sure at this time, elements in 'stars' and 'sph.gas_particles' are the same
resolve_sinks(sph, stars, cloud, density_threshold, t)
# evolve for one diagnostic timestep
#grav_sph.evolve_model(t, timestep=dt_bridge)
sph.evolve_model(t, timestep=dt_sph)
#channel_from_grav_to_cluster.copy()
channel_from_sph_to_cloud.copy()
channel_from_sph_to_cluster.copy()
if len(stars) > 0:
newstars = cluster.select_array(
lambda birth_age: birth_age >= 0. | unit_time, ["birth_age"])
cluster.remove_particles(newstars)
# merge two stars if they are too close to each other (distance < merge_radius)
# typically we don't consider merging event since it is very rare given a reasonable merge radius
if merge == True:
merge_stars(sph, stars, merge_radius)
with open(printout_file, 'a') as pf:
pf.write('Number of stars in `cluster`= %d; in `stars` = %d; in `sph.dm_particles`= %d.\n'\
%(len(cluster), len(stars), len(sph.dm_particles)))
# make snapshots
plot_cloud_cluster(cluster, sph, stars, title='{0}'.format(float(t.value_in(units.Myr))),\
vrange=[-5,3])
# save data (energy will be added afterwards)
lr_cloud = Lagrange_radii(cloud, converter_sph)
lr_cloud_list.append(lr_cloud)
lr_cluster = Lagrange_radii(cluster, converter_grav)
lr_cluster_list.append(lr_cluster)
E_cloud = get_energy(cloud, norm=Etot0_cloud)
E_cloud_list.append(E_cloud)
E_cluster = get_energy(cluster, norm=Etot0_cluster)
E_cluster_list.append(E_cluster)
n_formed_star.append(len(stars))
# save data instantaneously
lr_data = np.concatenate(
([t.value_in(unit_time)], lr_cloud, lr_cluster))
E_data = np.concatenate(([t.value_in(unit_time)], E_cloud, E_cluster))
with open('lr_data.txt', 'a') as f_lr_data:
f_lr_data.write(','.join(str(x) for x in lr_data) + '\n')
with open('E_data.txt', 'a') as f_E_data:
f_E_data.write(','.join(str(x) for x in E_data) + '\n')
with open('formed_star_data.txt', 'a') as f_fs_data:
f_fs_data.write('%f,%d\n' % (t.value_in(unit_time), len(stars)))
with open(printout_file, 'a') as pf:
pf.write(f'Finished.\n')
#gravity.stop()
sph.stop()
return times.value_in(
unit_time
), n_formed_star, lr_cloud_list, lr_cluster_list, E_cloud_list, E_cluster_list
def fi(self):
return Fi(convert_nbody_units)
def test5(self):
self.skip("Fi does not support removal of particles")
instance = Fi()
self._run_addition_removal_test(instance)
def make_xyz(self):
from amuse.community.fi.interface import Fi
N = self.targetN
target_rms = self.target_rms
L = 1 | nbody_system.length
dt = 0.01 | nbody_system.time
x, y, z = uniform_random_unit_cube(N).make_xyz()
vx, vy, vz = uniform_unit_sphere(N).make_xyz()
p = Particles(N)
p.x = L * x
p.y = L * y
p.z = L * z
p.h_smooth = 0. * L
p.vx = 0.1 * vx | (nbody_system.speed)
p.vy = 0.1 * vy | (nbody_system.speed)
p.vz = 0.1 * vz | (nbody_system.speed)
p.u = (0.1 * 0.1) | nbody_system.speed**2
p.mass = (8. / N) | nbody_system.mass
sph = Fi(use_gl=False, mode='periodic', redirection='none')
sph.initialize_code()
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = False
sph.parameters.gamma = 1.
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = dt
sph.parameters.verbosity = 0
sph.parameters.periodic_box_size = 2 * L
sph.parameters.artificial_viscosity_alpha = 1.
sph.parameters.beta = 2.
sph.commit_parameters()
sph.gas_particles.add_particles(p)
sph.commit_particles()
# sph.start_viewer()
t = 0. | nbody_system.time
rms = 1.
minrms = 1.
i = 0
while rms > target_rms:
i += 1
t = t + (0.25 | nbody_system.time)
sph.evolve_model(t)
rho = sph.particles.rho.value_in(nbody_system.density)
rms = rho.std() / rho.mean()
minrms = min(minrms, rms)
if rms > 2. * minrms or i > 300:
print " RMS(rho) convergence warning:", i, rms, minrms
if i > 100000:
print "i> 100k steps - not sure about this..."
print " rms:", rms
break
x = sph.particles.x.value_in(nbody_system.length)
y = sph.particles.y.value_in(nbody_system.length)
z = sph.particles.z.value_in(nbody_system.length)
del sph
return x, y, z
def test5(self):
instance = Fi()
self._run_addition_removal_test(instance)
def glass(self):
from amuse.community.fi.interface import Fi
if self.target_rms < 0.0001:
print("warning: target_rms may not succeed")
if self.number_of_particles < 1000:
print("warning: not enough particles")
N = 2 * self.number_of_particles
L = 1 | nbody_system.length
dt = 0.01 | nbody_system.time
x, y, z = self._random_cube(N)
vx,vy,vz= self.random(N)
p = Particles(N)
p.x = L * x
p.y = L * y
p.z = L * z
p.h_smooth = 0.0 | nbody_system.length
p.vx = (0.1 | nbody_system.speed) * vx[:N]
p.vy = (0.1 | nbody_system.speed) * vy[:N]
p.vz = (0.1 | nbody_system.speed) * vz[:N]
p.u = (0.1*0.1) | nbody_system.speed**2
p.mass = (8.0/N) | nbody_system.mass
sph = Fi(mode = 'periodic', redirection = 'none')
sph.initialize_code()
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = False
sph.parameters.gamma = 1.0
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = dt
sph.parameters.verbosity = 0
sph.parameters.periodic_box_size = 2 * L
sph.parameters.artificial_viscosity_alpha = 1.0
sph.parameters.beta = 2.0
sph.commit_parameters()
sph.gas_particles.add_particles(p)
sph.commit_particles()
t = 0.0 | nbody_system.time
rms = 1.0
minrms = 1.0
i = 0
while rms > self.target_rms:
i += 1
t += (0.25 | nbody_system.time)
sph.evolve_model(t)
rho = sph.particles.rho.value_in(nbody_system.density)
rms = rho.std()/rho.mean()
minrms = min(minrms, rms)
if (rms > 2.0*minrms) or (i > 300):
print(" RMS(rho) convergence warning:", i, rms, minrms)
if i > 100000:
print("i> 100k steps - not sure about this...")
print(" rms:", rms)
break
x = sph.particles.x.value_in(nbody_system.length)
y = sph.particles.y.value_in(nbody_system.length)
z = sph.particles.z.value_in(nbody_system.length)
sph.stop()
del sph
return self._cutout_sphere(x, y, z)
def run_molecular_cloud(N=100, Mcloud=100. | units.MSun, Rcloud=1. | units.parsec):
conv = nbody_system.nbody_to_si(Mcloud,Rcloud)
rho_cloud = 3.*Mcloud/(4.*numpy.pi*Rcloud**3)
print rho_cloud
tff = 0.5427/numpy.sqrt(constants.G*rho_cloud)
print "t_ff=", tff.value_in(units.Myr), 'Myr'
dt = 5.e-2 | units.Myr
tend=1.0 | units.Myr
# tend=2.0 | units.Myr
parts=molecular_cloud(targetN=N,convert_nbody=conv,
base_grid=body_centered_grid_unit_cube, seed=100).result
sph=Fi(conv, number_of_workers=3)
sph.parameters.use_hydro_flag=True
sph.parameters.radiation_flag=False
sph.parameters.gamma=1
sph.parameters.isothermal_flag=True
sph.parameters.integrate_entropy_flag=False
sph.parameters.timestep=dt
sph.parameters.verbosity = 0
sph.parameters.eps_is_h_flag = False# h_smooth is constant
eps = 0.1 | units.parsec
sph.parameters.gas_epsilon = eps
sph.parameters.sph_h_const = eps
parts.h_smooth= eps
print 'eps-h flag', sph.get_eps_is_h(), sph.get_consthsm()
expected_dt = 0.2*numpy.pi*numpy.power(eps, 1.5)/numpy.sqrt(constants.G*Mcloud/N)
print "dt_exp=", expected_dt.value_in(units.Myr)
print "dt=", dt
print "eps=", sph.parameters.gas_epsilon.in_(units.parsec)
sph.gas_particles.add_particles(parts)
#grav=copycat(Fi, sph, conv)
#sys=bridge(verbose=False)
#sys.add_system(sph,(grav,),False)
channel_from_sph_to_parts= sph.gas_particles.new_channel_to(parts)
channel_from_parts_to_sph= parts.new_channel_to(sph.gas_particles)
i=0
L=6
E0 = 0.0
ttarget = 0.0 | units.Myr
plot_hydro(ttarget, sph, i, L)
while ttarget < tend:
ttarget=float(i)*dt
print ttarget
sph.evolve_model(ttarget, timestep=dt)
E = sph.gas_particles.kinetic_energy()+sph.gas_particles.potential_energy() + sph.gas_particles.thermal_energy()
E_th = sph.gas_particles.thermal_energy()
if i==0:
E0 = E
Eerr = (E-E0)/E0
print 'energy=', E, 'energy_error=', Eerr, 'e_th=', E_th
channel_from_sph_to_parts.copy()
"""
filename = 'm400k_r10pc_e01_'+ str(i).zfill(2) + '.dat'
print filename
parts_sorted = parts.sorted_by_attribute('rho')
write_output(filename, parts_sorted, conv)
"""
plot_hydro(ttarget, sph, i, L)
i=i+1
plot_hydro_and_stars(ttarget, sph, L)
sph.stop()
return parts
def evolve(Sun_Jupiter, disk_gas, sink, Pstar, dt_gravity, dt_sph,
dt_diagnostic, dt_bridge, tend):
Sun = Sun_Jupiter[0]
Jupiter = Sun_Jupiter[1]
# Initialising the SPH code
sph_converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
sph = Fi(sph_converter, mode="openmp")
sph.gas_particles.add_particles(disk_gas)
sph.dm_particles.add_particle(Sun)
sph.dm_particles.add_particle(Jupiter)
sph.dm_particles.add_particle(Pstar)
# Set up channels for updating the particles
sph_to_disk = sph.gas_particles.new_channel_to(disk_gas)
sph_to_Sun_Jupiter = sph.dm_particles.new_channel_to(Sun_Jupiter)
sph_to_Pstar = sph.dm_particles.new_channel_to(Pstar)
Sun_Jupiter_to_sph = Sun_Jupiter.new_channel_to(sph.dm_particles)
disk_to_sph = disk_gas.new_channel_to(sph.gas_particles)
Pstar_to_sph = Pstar.new_channel_to(sph.dm_particles)
# Preparing lists for data-recording
a_Jup = []
e_Jup = []
disk_size = []
accreted_mass = []
accreted_mass.append((sink.mass).value_in(units.MJupiter)[0])
sink0_mass = 0 | units.MJupiter
# Start evolution
print 'Start evolving...'
times = quantities.arange(0. | units.yr, tend, dt_diagnostic)
for i, t in enumerate(times):
# Save the data for plots
orbit = orbital_elements_from_binary(Sun_Jupiter, G=constants.G)
a = orbit[2].value_in(units.AU)
e = orbit[3]
lr9 = return_L9_radius(disk_gas, Sun_Jupiter[0].mass, Rmin)
a_Jup.append(a)
e_Jup.append(e)
disk_size.append(lr9)
# Plotting system
print 'Time = %.1f yr:'%t.value_in(units.yr), \
'a = %.2f au, e = %.2f,'%(a, e), \
'disk size = %.2f au'%lr9
plot_map(sph,
Sun_Jupiter,
Pstar,
'distribution_plot_passing_star_full_hydro_4k/{0}.png'.format(
int(t.value_in(units.yr))),
show=False)
# Evolve the bridge system for one step
sph.evolve_model(t, dt_diagnostic)
sph_to_disk.copy()
sph_to_Sun_Jupiter.copy()
sph_to_Pstar.copy()
# Calculating accreted mass in new position
sink.position = Jupiter.position
sink.radius = Hill_radius(a, e, Sun_Jupiter) | units.AU
removed_particles = hydro_sink_particles(sink, disk_gas)
Jupiter.mass += sink.mass - sink0_mass
accreted_mass.append((sink.mass).value_in(units.MJupiter)[0])
sink0_mass = sink.mass.copy()
Sun_Jupiter_to_sph.copy()
disk_to_sph.copy()
Sun_Jupiter_to_sph.copy()
Pstar_to_sph.copy()
sph.stop()
return times, a_Jup, e_Jup, disk_size, accreted_mass
proto = ProtoPlanetaryDisk(
N, convert_nbody=convert, densitypower=1.5, Rmin=4, Rmax=20, q_out=1.)
gas = proto.result
gas.h_smooth = 0.06 | units.AU
sun = Particles(1)
sun.mass = Mstar
sun.radius = 2. | units.AU
sun.x = 0. | units.AU
sun.y = 0. | units.AU
sun.z = 0. | units.AU
sun.vx = 0. | units.kms
sun.vy = 0. | units.kms
sun.vz = 0. | units.kms
sph = Fi(convert)
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = True
sph.parameters.gamma = 1.
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = 0.125 | units.yr
sph.gas_particles.add_particles(gas)
sph.particles.add_particles(sun)
sph.evolve_model(tend)
L = 50
def res_increase(
gas=None,
recalculate_h_density=False,
seed=123,
make_cutout=False,
make_circular_cutout=False,
circular_rmax=3000 | units.pc,
x_center=None,
y_center=None,
width=None,
res_increase_factor=85,
):
numpy.random.seed(seed)
if gas is None:
if len(sys.argv) > 2:
from amuse.io import read_set_from_file
filename = sys.argv[1]
res_increase_factor = int(sys.argv[2])
gas = read_set_from_file(filename, 'amuse')
if hasattr(gas, "itype"):
gas = gas[gas.itype == 1]
del gas.itype
else:
from amuse.ic.gasplummer import new_plummer_gas_model
converter = nbody_system.nbody_to_si(10000 | units.MSun,
10 | units.pc)
filename = "test"
gas = new_plummer_gas_model(10000, converter)
res_increase_factor = 85
sph = Fi(converter, mode="openmp")
gas_in_code = sph.gas_particles.add_particles(gas)
gas.h_smooth = gas_in_code.h_smooth
gas.density = gas_in_code.density
sph.stop()
write_set_to_file(gas, "old-%s" % filename, "amuse")
print("old gas created")
if make_circular_cutout:
r2 = gas.x**2 + gas.y**2
cutout = gas[r2 <= circular_rmax**2]
gas = cutout
converter = nbody_system.nbody_to_si(gas.total_mass(), width)
sph = Fi(converter, mode="openmp")
gas_in_code = sph.gas_particles.add_particles(gas)
gas.h_smooth = gas_in_code.h_smooth
gas.density = gas_in_code.density
sph.stop()
if make_cutout:
if (x_center is None or y_center is None or width is None):
raise Exception("Need to set x_center, y_center and width!")
cutout = gas.sorted_by_attribute("x")
cutout = cutout[cutout.x - x_center < width / 2]
cutout = cutout[cutout.x - x_center > -width / 2]
cutout = cutout.sorted_by_attribute("y")
cutout = cutout[cutout.y - y_center < width / 2]
cutout = cutout[cutout.y - y_center > -width / 2]
gas = cutout
converter = nbody_system.nbody_to_si(gas.total_mass(), width)
sph = Fi(converter, mode="openmp")
gas_in_code = sph.gas_particles.add_particles(gas)
gas.h_smooth = gas_in_code.h_smooth
gas.density = gas_in_code.density
sph.stop()
# boundary = test_cutout.h_smooth.max()
if res_increase_factor == 1:
return gas
original_number_of_particles = len(gas)
new_number_of_particles = (res_increase_factor *
original_number_of_particles)
converter = nbody_system.nbody_to_si(
gas.total_mass(),
1 | units.kpc,
)
new_gas = Particles(new_number_of_particles)
# new_gas.h_smooth = gas.h_smooth
shells, particles_per_shell, shell_radii = find_shell_struct(
res_increase_factor)
relative_positions = pos_shift(
shell_radii,
particles_per_shell,
res_increase_factor=res_increase_factor,
)
relative_velocities = numpy.zeros(
res_increase_factor * 3, dtype=float).reshape(res_increase_factor,
3) | gas.velocity.unit
random_samples = 50
number_of_particles = len(gas)
starting_index = 0
for r in range(random_samples):
print("%i / %i random sample done" % (r, random_samples))
number_of_particles_remaining = len(gas)
number_of_particles_in_sample = min(
number_of_particles_remaining,
int(1 + number_of_particles / random_samples))
gas_sample = gas.random_sample(number_of_particles_in_sample).copy()
gas.remove_particles(gas_sample)
end_index = (starting_index +
number_of_particles_in_sample * res_increase_factor)
new_gas_sample = new_gas[starting_index:end_index]
psi = 2 * numpy.pi * numpy.random.random()
theta = 2 * numpy.pi * numpy.random.random()
phi = 2 * numpy.pi * numpy.random.random()
relative_positions = rotated(relative_positions, phi, theta, psi)
# print(len(gas_sample), len(new_gas_sample))
for i in range(res_increase_factor):
new_gas_sample[i::res_increase_factor].mass = (gas_sample.mass /
res_increase_factor)
new_gas_sample[i::res_increase_factor].x = (
gas_sample.x + relative_positions[i, 0] * gas_sample.h_smooth)
new_gas_sample[i::res_increase_factor].y = (
gas_sample.y + relative_positions[i, 1] * gas_sample.h_smooth)
new_gas_sample[i::res_increase_factor].z = (
gas_sample.z + relative_positions[i, 2] * gas_sample.h_smooth)
new_gas_sample[i::res_increase_factor].vx = (
gas_sample.vx + relative_velocities[i, 0])
new_gas_sample[i::res_increase_factor].vy = (
gas_sample.vy + relative_velocities[i, 1])
new_gas_sample[i::res_increase_factor].vz = (
gas_sample.vz + relative_velocities[i, 2])
new_gas_sample[i::res_increase_factor].density = gas_sample.density
new_gas_sample[i::res_increase_factor].u = gas_sample.u
starting_index += number_of_particles_in_sample * res_increase_factor
new_gas.h_smooth = ((3 * new_gas.mass / (4 * pi * new_gas.density))**(1 /
3))
# sph = Fi(converter, mode="openmp", redirection="none")
# new_gas_in_code = sph.gas_particles.add_particles(new_gas)
# new_gas.h_smooth = new_gas_in_code.h_smooth
# new_gas.density = new_gas_in_code.density
# sph.stop()
print("particles now have a mass of %s" %
(new_gas[0].mass.in_(units.MSun)))
return new_gas
Rmax=20,
q_out=1.)
gas = proto.result
gas.h_smooth = 0.06 | units.AU
sun = Particles(1)
sun.mass = Mstar
sun.radius = 2. | units.AU
sun.x = 0. | units.AU
sun.y = 0. | units.AU
sun.z = 0. | units.AU
sun.vx = 0. | units.kms
sun.vy = 0. | units.kms
sun.vz = 0. | units.kms
sph = Fi(convert)
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = True
sph.parameters.gamma = 1.
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = 0.125 | units.yr
sph.gas_particles.add_particles(gas)
sph.particles.add_particles(sun)
sph.evolve_model(tend)
L = 50
def evolve(cluster,cloud, converter_grav,converter_sph, t_end, dt_sph, dt_diag,\
sink=True, merge=False):
with open(printout_file, 'a') as pf:
pf.write('Setting up the hydro code...\n')
'''# Initialising the direct N-body integrator
gravity = ph4(converter_grav)
gravity.particles.add_particles(cluster)'''
# Initialising the hydro code
sph = Fi(converter_sph, mode="openmp")
sph.gas_particles.add_particles(cloud)
sph.dm_particles.add_particles(cluster)
sph.parameters.radiation_flag = False
#sph.parameters.isothermal_flag = True
#sph.parameters.integrate_entropy_flag = False #should we consider isothermal process or adiabatic one?
sph.parameters.timestep = dt_sph
#sph.parameters.eps_is_h_flag = False # h_smooth is constant
#eps = 0.1 | units.parsec
#sph.parameters.gas_epsilon = eps
#sph.parameters.sph_h_const = eps
#cloud.h_smooth= eps
'''# Building a bridge between hydro and gravity
with open(printout_file, 'a') as pf:
pf.write('Bridging...\n')
grav_sph = bridge.Bridge(use_threading=False)
grav_sph.add_system(gravity, (sph,))
grav_sph.add_system(sph, (gravity,))
grav_sph.timestep = dt_bridge'''
# Setting up channels from code to cloud and cluster
#channel_from_grav_to_cluster = gravity.particles.new_channel_to(cluster)
channel_from_sph_to_cloud = sph.gas_particles.new_channel_to(cloud)
channel_from_sph_to_cluster = sph.dm_particles.new_channel_to(cluster)
# considers star formation
if sink == True:
with open(printout_file, 'a') as pf:
pf.write('[Star formation is considered.]\n')
# `stars` is initialized as a particle set for potential new stars forming in the cloud
stars = Particles(0)
sph.dm_particles.add_particles(stars)
# set a density threshold (Jeans density) in the sph code
density_threshold = Jeans_density(M=sph.gas_particles.mass.max())
with open('cloud_data.txt', 'a') as f_cd_data:
f_cd_data.write('# Jeans density of the cloud = %.5e kg/m^3\n' %
density_threshold.value_in(units.kg / units.m**3))
sph.parameters.stopping_condition_maximum_density = density_threshold
density_limit_detection = sph.stopping_conditions.density_limit_detection
density_limit_detection.enable()
# considers star merging
if merge == True:
merge_radius = 1e-4 | units.parsec # 1 pc = 206265 AU
with open(printout_file, 'a') as pf:
pf.write('[Star merging is considered.]\n')
# Initializing data lists
lr_cloud_list = [Lagrange_radii(cloud, converter_sph)]
lr_cluster_list = [Lagrange_radii(cluster, converter_grav)]
E_norm = 1e42 | (units.kg * units.m**2 / units.s**2)
E0_cloud = get_energy(cloud, E_norm)
#Etot0_cloud = E0_cloud[-1]
E_cloud_list = [E0_cloud]
E0_cluster = get_energy(cluster)
#Etot0_cluster = E0_cluster[-1]
E_cluster_list = [E0_cluster]
n_formed_star = [0]
max_gas_density = [
sph.gas_particles.density.max().value_in(units.kg / units.m**3)
]
# unify the unit of times
unit_time = units.Myr
t_end = t_end.in_(unit_time)
dt_diag = dt_diag.in_(unit_time)
dt_sph = dt_sph.in_(unit_time)
times = quantities.arange(0. | unit_time, t_end + dt_diag, dt_diag)
with open(printout_file, 'a') as pf:
pf.write('\nStart evolving the molecular cloud...\n')
pf.write(
f'End time = {t_end}; Diagnostic timestep = {dt_diag}; Initial SPH timestep = {dt_sph}.\n'
)
# Real start for evolution!
for i, t in enumerate(times):
with open(printout_file, 'a') as pf:
pf.write(f'---------- Time = {t.in_(units.Myr)} ----------\n')
# calculates the dynamical(dyn), half-mass relaxation(rh), and free-fall(ff) timescales
# for both the cloud and the cluster
t_dyn_cloud, t_rh_cloud, t_ff_cloud = timescale(cloud, unit_time)
t_dyn_cluster, t_rh_cluster, t_ff_cluster = timescale(
cluster, unit_time)
all_timescales = [
t_dyn_cloud, t_rh_cloud, t_ff_cloud, t_dyn_cluster, t_rh_cluster,
t_ff_cluster
] | unit_time
shortest_ts = all_timescales.amin()
dt_sph = np.round(
(shortest_ts / 10.).value_in(unit_time), 2) | unit_time
with open(printout_file, 'a') as pf:
pf.write(
'Current evolve timestep: %.2f Myr; Shortest timescale: %.2f Myr.\n'
%
(dt_sph.value_in(unit_time), shortest_ts.value_in(unit_time)))
# considers star information
# (make sure that at this time, elements in 'stars' and 'sph.gas_particles' are the same)
if sink == True:
resolve_sinks(sph, stars, cloud, density_threshold, t)
# evolve for one diagnostic timestep
#grav_sph.evolve_model(t, timestep=dt_bridge)
sph.evolve_model(t, timestep=dt_sph)
#channel_from_grav_to_cluster.copy()
channel_from_sph_to_cloud.copy()
channel_from_sph_to_cluster.copy()
# remove newly formed stars from `cluster` after using channels
# (since both `stars` and `cluster` are added as dm_particles in sph, we have to distinguish them by `birth_age`)
if len(stars) > 0:
newstars = cluster.select_array(
lambda birth_age: birth_age >= 0. | unit_time, ["birth_age"])
cluster.remove_particles(newstars)
# merge two stars if they are too close to each other (distance < merge_radius)
# typically we don't consider merging event since it is very rare given a reasonable merge radius
if merge == True:
merge_stars(sph, stars, merge_radius)
# sanity check
with open(printout_file, 'a') as pf:
pf.write('Number of stars in `cluster`= %d; in `stars` = %d; in `sph.dm_particles`= %d.\n'\
%(len(cluster), len(stars), len(sph.dm_particles)))
# make snapshots
plot_cloud_cluster(cluster, sph, stars, title='{0}'.format(float(t.value_in(units.Myr))),\
vrange=[-5,3])
# save data
lr_cloud = Lagrange_radii(cloud, converter_sph)
lr_cloud_list.append(lr_cloud)
lr_cluster = Lagrange_radii(cluster, converter_grav)
lr_cluster_list.append(lr_cluster)
E_cloud = get_energy(cloud, norm=E_norm)
E_cloud_list.append(E_cloud)
E_cluster = get_energy(cluster, norm=E_norm)
E_cluster_list.append(E_cluster)
n_formed_star.append(len(stars))
max_gas_density.append(sph.gas_particles.density.max().value_in(
units.kg / units.m**3))
# save data instantaneously
lr_data = np.concatenate(
([t.value_in(unit_time)], lr_cloud, lr_cluster))
E_data = np.concatenate(([t.value_in(unit_time)], E_cloud, E_cluster))
with open('lr_data.txt', 'a') as f_lr_data:
f_lr_data.write(','.join(str(x) for x in lr_data) + '\n')
with open('E_data.txt', 'a') as f_E_data:
f_E_data.write(','.join(str(x) for x in E_data) + '\n')
with open('cloud_data.txt', 'a') as f_cd_data:
f_cd_data.write('%.2f,%d,%.5e\n'%(t.value_in(unit_time), len(stars),\
sph.gas_particles.density.max().value_in(units.kg/units.m**3)))
with open(printout_file, 'a') as pf:
pf.write(f'Finished.\n')
#gravity.stop()
sph.stop()
return times.value_in(unit_time), n_formed_star, max_gas_density,\
lr_cloud_list, lr_cluster_list, E_cloud_list, E_cluster_list
def evolve(cluster, cloud, t_end, dt_bridge, dt_diag):
converter = nbody_system.nbody_to_si(1. | units.MSun, 1. | units.parsec)
# Initialising the direct N-body integrator
print('Setting up the gravity code and the hydro code...')
gravity = ph4(converter)
gravity.particles.add_particles(cluster)
# Initialising the hydro code
sph = Fi(converter, mode="openmp")
sph.gas_particles.add_particles(cloud)
#sph.parameters.use_hydro_flag = True
#sph.parameters.radiation_flag = False
#sph.parameters.gamma = 1
#sph.parameters.isothermal_flag = True
#sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = dt_diag
#sph.parameters.verbosity = 0
#sph.parameters.eps_is_h_flag = False # h_smooth is constant
#eps = 0.1 | units.parsec
#sph.parameters.gas_epsilon = eps
#sph.parameters.sph_h_const = eps
#cloud.h_smooth= eps
print("cloud:", sph.gas_particles)
plt.scatter(
np.log10(sph.gas_particles.density.value_in(units.g / units.cm**3)),
sph.gas_particles.pressure.value_in(units.kg / units.m / units.s**2),
s=10)
plt.show()
# Building a bridge between hydro and grav
print('Bridging...')
grav_sph = bridge.Bridge(use_threading=False)
grav_sph.add_system(gravity, (sph, ))
grav_sph.add_system(sph, (gravity, ))
grav_sph.timestep = dt_bridge
# Setting up channels from code to cloud and cluster
channel_from_grav_to_cluster = gravity.particles.new_channel_to(cluster)
channel_from_sph_to_cloud = sph.gas_particles.new_channel_to(cloud)
# Initializing 90 percent lagrangian radius
lr9 = []
lr9.append(L9_radius(cloud, converter))
# Evolving
print('Start evolving the molecular cloud...')
times = quantities.arange(0. | units.Myr, t_end, dt_diag)
for i, t in enumerate(times):
print(t.in_(units.Myr))
grav_sph.evolve_model(t, dt_diag)
channel_from_grav_to_cluster.copy()
channel_from_sph_to_cloud.copy()
plot_cloud_cluster(cluster, sph, title='{0}'.format(float(t.value_in(units.Myr))),\
L=400, vrange=[-5,1])
lr9.append(L9_radius(cloud, converter))
#print("cloud:", sph.gas_particles)
#xx
#plt.scatter(np.log10(sph.gas_particles.density.value_in(units.g/units.cm**3)),
# sph.gas_particles.pressure.value_in(units.kg/units.m/units.s**2), s=10)
plt.show()
gravity.stop()
sph.stop()
return lr9
def __init__(self, *args, **kargs):
Fi.__init__(self, *args, **kargs)
self.escapers = core.Particles(0)
N_particles = 1000 # Number of SPH particles
disk = ProtoPlanetaryDisk(N_particles,
convert_nbody=converter,
densitypower=1.5,
Rmin=0.5,
Rmax=100,
q_out=1.) # Rmin and Rmax in AU
disk_particles = disk.result # Disk particles
disk_particles.h_smooth = 0.06 | units.au # Smoothing length
# Rotate the disk 90 degrees around x axis
disk = rotate(disk_particles, 90, 0, 0)
# Start SPH code and add particles
sph = Fi(converter)
sph.gas_particles.add_particles(
disk_particles) # Disk particles are added as gas particles
sph.dm_particles.add_particles(
stars[0]) # Star is added as dark matter particle
# Evolve code in time steps
t_end = 100 | units.yr
dt = 1 | units.yr
t = 0 | units.yr
while t < t_end:
t += dt
print t
sph.evolve_model(t)
def evolve(Sun_Jupiter, disk_gas, sink, Pstar, dt_gravity, dt_sph,
dt_diagnostic, dt_bridge, tend):
Sun = Sun_Jupiter[0]
Jupiter = Sun_Jupiter[1]
# Initialising the direct N-body integrator
#gravity_converter = nbody_system.nbody_to_si(Jupiter.mass, Jupiter.position.length())
gravity_converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
gravity = ph4(gravity_converter)
gravity.particles.add_particle(Jupiter)
#gravity.particles.add_particle(Pstar)
gravity.timestep = dt_gravity
# Initialising the SPH code
sph_converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
#sph_converter = nbody_system.nbody_to_si(Pstar.mass.sum(), Rmin)
sph = Fi(sph_converter, mode="openmp")
sph.gas_particles.add_particles(disk_gas)
sph.dm_particles.add_particle(Sun)
#sph.dm_
sph.dm_particles.add_particle(Pstar)
sph.parameters.timestep = dt_sph
print 'Bridging...'
# Build up the bridge between gravity and hydrodynamics
grav_sph = bridge.Bridge(use_threading=False)
grav_sph.add_system(gravity, (sph, ))
grav_sph.add_system(sph, (gravity, ))
grav_sph.timestep = dt_bridge
# Set up channels for updating the particles
gravity_to_Jupiter = gravity.particles.new_channel_to(Sun_Jupiter)
sph_to_disk = sph.gas_particles.new_channel_to(disk_gas)
sph_to_Sun = sph.dm_particles.new_channel_to(Sun_Jupiter)
sph_to_Pstar = sph.dm_particles.new_channel_to(Pstar)
Jupiter_to_gravity = Sun_Jupiter.new_channel_to(gravity.particles)
disk_to_sph = disk_gas.new_channel_to(sph.gas_particles)
Sun_to_sph = Sun_Jupiter.new_channel_to(sph.dm_particles)
Pstar_to_sph = Pstar.new_channel_to(sph.dm_particles)
'''
gravity_to_Jupiter = gravity.particles.new_channel_to(Sun_Jupiter)
gravity_to_Pstar = gravity.particles.new_channel_to(Pstar)
sph_to_disk = sph.gas_particles.new_channel_to(disk_gas)
sph_to_Sun = sph.dm_particles.new_channel_to(Sun_Jupiter)
Jupiter_to_gravity = Sun_Jupiter.new_channel_to(gravity.particles)
Pstar_to_gravity = Pstar.new_channel_to(gravity.particles)
disk_to_sph = disk_gas.new_channel_to(sph.gas_particles)
Sun_to_sph = Sun_Jupiter.new_channel_to(sph.dm_particles)
'''
# Sanity checks:
print('Sanity checks:')
#print('Star coordinates (AU)',Pstar.x.value_in(units.AU),
# Pstar.y.value_in(units.AU),
# Pstar.z.value_in(units.AU))
print('Disk particle map saved to: initial_check_disk.png')
#plot_map(sph, Sun_Jupiter, Pstar,'initial_check_disk.png',show=True)
a_Jup = []
e_Jup = []
disk_size = []
accreted_mass = []
# start evolotuion
print 'Start evolving...'
times = quantities.arange(0. | units.yr, tend, dt_diagnostic)
for i, t in enumerate(times):
# Save the data for plots
orbit = orbital_elements_from_binary(Sun_Jupiter, G=constants.G)
a = orbit[2].value_in(units.AU)
e = orbit[3]
lr9 = return_L9_radius(disk_gas, Sun_Jupiter[0].mass, Rmin)
a_Jup.append(a)
e_Jup.append(e)
disk_size.append(lr9)
accreted_mass.append((sink.mass).value_in(units.MJupiter)[0])
# Plotting
#print('Star coordinates (AU)',Pstar.x.value_in(units.AU),
# Pstar.y.value_in(units.AU),
# Pstar.z.value_in(units.AU))
print 'Time = %.1f yr:'%t.value_in(units.yr), \
'a = %.2f au, e = %.2f,'%(a, e), \
'disk size = %.2f au'%lr9
plot_map(sph,
Sun_Jupiter,
Pstar,
'distribution_plot_passing_star_grav/{0}.png'.format(
int(t.value_in(units.yr))),
show=False)
# Evolve the bridge system for one step
grav_sph.evolve_model(t, dt_diagnostic)
gravity_to_Jupiter.copy()
sph_to_disk.copy()
sph_to_Sun.copy()
sph_to_Pstar.copy()
# Add the 'sinked' mass to Jupiter & keep the sink particle along with Jupiter
removed_particles = hydro_sink_particles(sink, disk_gas)
Jupiter = gravity.particles[0]
Jupiter.mass += sink.mass
sink.position = Jupiter.position
sink.radius = Hill_radius(a, e, Sun_Jupiter) | units.AU
Jupiter_to_gravity.copy()
disk_to_sph.copy()
Sun_to_sph.copy()
Pstar_to_sph.copy()
gravity.stop()
sph.stop()
return t, a_Jup, e_Jup, disk_size, accreted_mass
def main(t_end=1000. | units.yr, dt=10. | units.yr):
print 'Initializing...'
#converter = nbody_system.nbody_to_si(1.|units.MSun, 1.|units.AU)
# Initialize the Sun and Jupiter system
Sun, Jupiter = init_star_planet()
Sun_and_Jupiter0 = Particles()
Sun_and_Jupiter0.add_particle(Sun)
Sun_and_Jupiter0.add_particle(Jupiter)
orbit0 = orbital_elements_from_binary(Sun_and_Jupiter0, G=constants.G)
a0 = orbit0[2].in_(units.AU)
e0 = orbit0[3]
Hill_radius0 = a0 * (1 - e0) * (
(1.0 | units.MJupiter).value_in(units.MSun) / 3.)**(1. / 3.)
# Initialize the passing star
PassStar = Particle()
PassStar.mass = 2.0 | units.MSun
r_ps = 200. | units.AU
a_ps = 1000. | units.AU
mu = PassStar.mass * Sun.mass / (PassStar.mass + Sun.mass)
vx = np.sqrt(constants.G * mu * (2. / r_ps - 1. / a_ps)).in_(units.kms)
PassStar.velocity = (-vx, 0. | units.kms, 0. | units.kms)
ds = (Jupiter.position - Sun.position).value_in(units.AU)
sin_theta = ds[2] / np.sqrt(ds[0]**2 + ds[1]**2)
cos_theta = np.sqrt(1 - sin_theta**2)
PassStar.position = (Sun.position).in_(units.AU) + (
(0., 200. * cos_theta, 200. * sin_theta) | units.AU)
# Initialize the direct N-body integrator
gravity_particles = Particles()
gravity_particles.add_particle(Jupiter)
gravity_particles.add_particle(PassStar)
converter_gravity = nbody_system.nbody_to_si(
gravity_particles.mass.sum(), gravity_particles.position.length())
gravity = ph4(converter_gravity)
gravity.particles.add_particles(gravity_particles)
gravity.timestep = dt
# Set proto-disk parameters
N = 4000
Mstar = 1. | units.MSun
Mdisk = 0.01 * Mstar
Rmin = 1. | units.AU
Rmax = 100. | units.AU
# Initialize the proto-planetary disk
np.random.seed(1)
converter_disk = nbody_system.nbody_to_si(Mstar, Rmin)
disk = ProtoPlanetaryDisk(N,
convert_nbody=converter_disk,
densitypower=1.5,
Rmin=1.,
Rmax=Rmax / Rmin,
q_out=1.,
discfraction=Mdisk / Mstar)
disk_gas = disk.result
disk_star = Particles()
disk_star.add_particle(Sun)
# Initialize the sink particle
sink = init_sink_particle(0. | units.MSun, Hill_radius0, Jupiter.position,
Jupiter.velocity)
# Initialising the SPH code
#converter_hydro = nbody_system.nbody_to_si(Mdisk, Rmax)
sph = Fi(converter_disk, mode="openmp")
sph.gas_particles.add_particles(disk_gas)
sph.dm_particles.add_particle(disk_star)
sph.parameters.timestep = dt
# bridge and evolve
times, a_Jup, e_Jup, disk_size, accreted_mass = gravity_hydro_bridge(gravity, sph, sink,\
[gravity_particles, disk_star, disk_gas], Rmin, t_end, dt)
return times, a_Jup, e_Jup, disk_size, accreted_mass
def run_mc(N=5000, Mcloud=10000. | units.MSun, Rcloud=1. | units.parsec):
conv = nbody_system.nbody_to_si(Mcloud, Rcloud)
interaction_timestep = 0.01 | units.Myr
time_end = 0.36 | units.Myr
parts = molecular_cloud(targetN=N,
convert_nbody=conv,
base_grid=body_centered_grid_unit_cube).result
sph = Fi(conv)
# need to turn off self gravity, the bridge will calculate this
sph.parameters.self_gravity_flag = False
# some typical Fi flags (just for reference, most are default values)
sph.parameters.use_hydro_flag = True
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.gamma = 1
sph.parameters.verbosity = 0
# setting the hydro timestep is important
# the sph code will take 2 timesteps every interaction timestep
sph.parameters.timestep = interaction_timestep / 2
sph.gas_particles.add_particles(parts)
def new_code_to_calculate_gravity_of_gas_particles():
result = BHTree(conv)
return result
calculate_gravity_code = bridge.CalculateFieldForCodes(
new_code_to_calculate_gravity_of_gas_particles, # the code that calculates the acceleration field
input_codes=[sph] # the codes to calculate the acceleration field of
)
bridged_system = bridge.Bridge()
bridged_system.timestep = interaction_timestep
bridged_system.add_system(
sph, # the code to move the particles of
[calculate_gravity_code
] # the codes that provide the acceleration field
)
fig = pyplot.figure(figsize=(12, 12))
ncolumn = 2
nrow = 2
nplot = ncolumn * nrow
grid_size = 3 | units.parsec
extent = (grid_size * (-0.5, 0.5, -0.5, 0.5)).value_in(units.parsec)
if nplot > 1:
plot_timestep = time_end / (nplot - 1)
else:
plot_timestep = time_end
for i in range(nplot):
ttarget = i * plot_timestep
print("evolving to time:", ttarget.as_quantity_in(units.Myr))
bridged_system.evolve_model(ttarget)
rho = make_map(sph, N=200, grid_size=grid_size)
subplot = fig.add_subplot(ncolumn, nrow, i + 1)
subplot.imshow(numpy.log10(1.e-5 +
rho.value_in(units.amu / units.cm**3)),
extent=extent,
vmin=1,
vmax=5)
subplot.set_title(ttarget.as_quantity_in(units.Myr))
sph.stop()
pyplot.show()
def make_xyz(self):
from amuse.community.fi.interface import Fi
N=self.targetN
target_rms=self.target_rms
L=1| nbody_system.length
dt=0.01 | nbody_system.time
x,y,z=uniform_random_unit_cube(N).make_xyz()
vx,vy,vz=uniform_unit_sphere(N).make_xyz()
p=Particles(N)
p.x=L*x
p.y=L*y
p.z=L*z
p.h_smooth=0. * L
p.vx= 0.1*vx | (nbody_system.speed)
p.vy= 0.1*vy | (nbody_system.speed)
p.vz= 0.1*vz | (nbody_system.speed)
p.u= (0.1*0.1) | nbody_system.speed**2
p.mass=(8./N) | nbody_system.mass
sph=Fi(use_gl=False,mode='periodic',redirection='none')
sph.initialize_code()
sph.parameters.use_hydro_flag=True
sph.parameters.radiation_flag=False
sph.parameters.self_gravity_flag=False
sph.parameters.gamma=1.
sph.parameters.isothermal_flag=True
sph.parameters.integrate_entropy_flag=False
sph.parameters.timestep=dt
sph.parameters.verbosity=0
sph.parameters.periodic_box_size=2*L
sph.parameters.artificial_viscosity_alpha = 1.
sph.parameters.beta = 2.
sph.commit_parameters()
sph.gas_particles.add_particles(p)
sph.commit_particles()
# sph.start_viewer()
t=0. | nbody_system.time
rms=1.
minrms=1.
i=0
while rms > target_rms:
i+=1
t=t+(0.25 | nbody_system.time)
sph.evolve_model(t)
rho=sph.particles.rho.value_in(nbody_system.density)
rms=rho.std()/rho.mean()
minrms=min(minrms,rms)
if rms>2.*minrms or i>300:
print " RMS(rho) convergence warning:", i, rms,minrms
if i>100000:
print "i> 100k steps - not sure about this..."
print " rms:", rms
break
x=sph.particles.x.value_in(nbody_system.length)
y=sph.particles.y.value_in(nbody_system.length)
z=sph.particles.z.value_in(nbody_system.length)
del sph
return x,y,z
def run_mc(N=5000, Mcloud=10000. | units.MSun, Rcloud=1. | units.parsec):
timestep = 0.005 | units.Myr
end_time = 0.12 | units.Myr
conv = nbody_system.nbody_to_si(Mcloud, Rcloud)
parts = molecular_cloud(targetN=N,
convert_nbody=conv,
ethep_ratio=0.05,
ekep_ratio=0.5).result
rho_cloud = Mcloud / (4 / 3. * numpy.pi * Rcloud**3)
tff = 1 / (4 * numpy.pi * constants.G * rho_cloud)**0.5
parts.density = rho_cloud
update_chem(parts, parts)
print("Tcloud:", parts.temperature.max().in_(units.K))
print("cloud n_H:", parts.number_density.max().in_(units.cm**-3))
print("freefall time:", tff.in_(units.Myr))
sph = Fi(conv)
chem = Krome(redirection="none")
sph.parameters.self_gravity_flag = True
sph.parameters.use_hydro_flag = True
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.gamma = 1
sph.parameters.verbosity = 0
sph.parameters.timestep = timestep / 2
sph.gas_particles.add_particles(parts)
chem.particles.add_particles(parts)
tnow = sph.model_time
f = pyplot.figure()
pyplot.ion()
pyplot.show()
i = 0
while i < (end_time / timestep + 0.5):
evolve_sph_with_chemistry(sph, chem, i * timestep)
tnow = sph.model_time
print("done with step:", i, tnow.in_(units.Myr))
i += 1
n = (sph.particles.density / meanmwt).value_in(units.cm**-3)
fh2 = chem.particles.abundances[:, chem.species["H2"]]
co = chem.particles.abundances[:, chem.species["CO"]]
f.clear()
pyplot.loglog(n, fh2, 'r.')
pyplot.loglog(n, co, 'g.')
pyplot.xlim(1.e3, 1.e6)
pyplot.ylim(1.e-6, 1)
pyplot.xlabel("density (cm**-3)")
pyplot.ylabel("H_2,CO abundance")
pyplot.draw()
print("done. press key to exit")
raw_input()
def glass(self):
from amuse.community.fi.interface import Fi
if self.target_rms < 0.0001:
print "warning: target_rms may not succeed"
if self.number_of_particles < 1000:
print "warning: not enough particles"
N = 2 * self.number_of_particles
L = 1 | nbody_system.length
dt = 0.01 | nbody_system.time
x, y, z = self._random_cube(N)
vx,vy,vz= self.random(N)
p = Particles(N)
p.x = L * x
p.y = L * y
p.z = L * z
p.h_smooth = 0.0 | nbody_system.length
p.vx = (0.1 | nbody_system.speed) * vx
p.vy = (0.1 | nbody_system.speed) * vy
p.vz = (0.1 | nbody_system.speed) * vz
p.u = (0.1*0.1) | nbody_system.speed**2
p.mass = (8.0/N) | nbody_system.mass
sph = Fi(mode = 'periodic', redirection = 'none')
sph.initialize_code()
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = False
sph.parameters.gamma = 1.0
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = dt
sph.parameters.verbosity = 0
sph.parameters.periodic_box_size = 2 * L
sph.parameters.artificial_viscosity_alpha = 1.0
sph.parameters.beta = 2.0
sph.commit_parameters()
sph.gas_particles.add_particles(p)
sph.commit_particles()
t = 0.0 | nbody_system.time
rms = 1.0
minrms = 1.0
i = 0
while rms > self.target_rms:
i += 1
t += (0.25 | nbody_system.time)
sph.evolve_model(t)
rho = sph.particles.rho.value_in(nbody_system.density)
rms = rho.std()/rho.mean()
minrms = min(minrms, rms)
if (rms > 2.0*minrms) or (i > 300):
print " RMS(rho) convergence warning:", i, rms, minrms
if i > 100000:
print "i> 100k steps - not sure about this..."
print " rms:", rms
break
x = sph.particles.x.value_in(nbody_system.length)
y = sph.particles.y.value_in(nbody_system.length)
z = sph.particles.z.value_in(nbody_system.length)
sph.stop()
del sph
return self._cutout_sphere(x, y, z)
def glass(N, target_rms=0.05):
"""
make glass for initial condition generation
"""
if target_rms < 0.001:
print "warning: target_rms highly unlikely to succeed"
L = 1 | nbody_system.length
dt = 0.01 | nbody_system.time
x, y, z = uniform_random_unit_cube(N).make_xyz()
vx, vy, vz = uniform_unit_sphere(N).make_xyz()
p = datamodel.Particles(N)
p.x = L * x
p.y = L * y
p.z = L * z
p.h_smooth = 0. * L
p.vx = 0.1 * vx | (nbody_system.speed)
p.vy = 0.1 * vy | (nbody_system.speed)
p.vz = 0.1 * vz | (nbody_system.speed)
p.u = (0.1 * 0.1) | nbody_system.speed**2
p.mass = (8. / N) | nbody_system.mass
sph = Fi(use_gl=False, mode='periodic', redirection='none')
sph.initialize_code()
sph.parameters.use_hydro_flag = True
sph.parameters.radiation_flag = False
sph.parameters.self_gravity_flag = False
sph.parameters.gamma = 1
sph.parameters.isothermal_flag = True
sph.parameters.integrate_entropy_flag = False
sph.parameters.timestep = dt
sph.parameters.verbosity = 0
sph.parameters.pboxsize = 2 * L
sph.parameters.artificial_viscosity_alpha = 1.
sph.parameters.beta = 2.
sph.commit_parameters()
sph.gas_particles.add_particles(p)
sph.commit_particles()
# sph.start_viewer()
t = 0. | nbody_system.time
rms = 1.
# i = 0
while rms > target_rms:
t = t + (0.25 | nbody_system.time)
sph.evolve_model(t)
h = sph.particles.h_smooth.value_in(nbody_system.length)
rho = h**(-3.)
rms = rho.std() / rho.mean()
print rms, target_rms
x = sph.particles.x.value_in(nbody_system.length)
y = sph.particles.y.value_in(nbody_system.length)
z = sph.particles.z.value_in(nbody_system.length)
sph.stop()
return x, y, z
def __init__(self, *args, **kargs): Fi.__init__(self, *args, **kargs) self.escapers=core.Particles(0)
def run_hydrodynamics(N=100, Mtot=1|units.MSun, Rvir=1|units.RSun,
t_end=0.5|units.day, n_steps=10,\
vx = 0 |(units.RSun/units.day),\
vy = 0 |(units.RSun/units.day),\
vz = 0 |(units.RSun/units.day),\
plummer1=None, plummer2=None,\
bodyname = None):
""" Runs the hydrodynamics simulation and returns a HydroResults
instance.
FUNCTION WALKTHROUGH:
In the following explanation 'plummer1' and 'plummer2' are assumed
to be hdf5 files written by the function write_set_to_file().
Case 1:
If 'plummer1' and 'plummer2' are filenames of hdf5 files, then these
two plummer spheres will be smashed together.
Case 2:
If only plummer1 is supplied, then it will evolve plummer1 with
t_end timerange and n_steps steps.
Case 3:
If no plummers spheres are supplied, then it will generate a new
plummer sphere using the default/supplied initial conditions.
OUTPUT FILES:
If 'results_out' is specified, the HydroResult instance is written
to file in HDF5 format. This however does not use
write_set_to_file() which writes the entire Particles class and
its attributes to file at each dt, but uses write_to_hdf5()
from the 'support' module which is tailored to writing
HydroResults instances to file. This HDF5 contains all necessary
data to plot the required plots of the assignment.
In addition, the last snapshot of the Particles instance is written
to file using write_set_to_file(), the latter file is written to
the 'bodies' directory. Only the last snapshot is written to file
because the history of a Particle set is not of interest when
reloading them to smash plummer spheres. """
converter = nbody_system.nbody_to_si(Mtot, Rvir)
fi = Fi(converter)
if plummer1 and plummer2:
eta_smash = 0.3 |units.day
if plummer1 == plummer2:
bodies1 = read_set_from_file(plummer1, format='hdf5')
bodies2 = bodies1.copy()
bodies2.key += 1
else:
bodies1 = read_set_from_file(plummer1, format='hdf5')
bodies2 = read_set_from_file(plummer2, format='hdf5')
bodies1.move_to_center()
bodies2.move_to_center()
if vx.value_in(vx.unit) == 0 and vy.value_in(vy.unit) == 0 \
and vz.value_in(vz.unit) == 0:
bodies1.x += -1 |units.RSun
bodies2.x += 1 |units.RSun
else:
bodies1.x += (-1)*vx*eta_smash
bodies2.x += 1*vx*eta_smash
bodies1.vx += vx
bodies2.vx += (-1)*vx
bodies1.vy += vy
bodies2.vy += (-1)*vy
bodies1.vz += vz
bodies2.vz += (-1)*vz
bodies1.add_particles(bodies2)
bodies = bodies1
elif plummer1 or plummer2:
if plummer1:
bodies = read_set_from_file(plummer1)
else:
bodies = read_set_from_file(plummer2)
bodies.move_to_center()
else:
bodies = new_plummer_gas_model(N, convert_nbody=converter)
fi.gas_particles.add_particles(bodies)
fi_to_framework = fi.gas_particles.new_channel_to(bodies)
fi.parameters.self_gravity_flag = True
data = {'lagrangianradii':AdaptingVectorQuantity(),\
'angular_momentum':AdaptingVectorQuantity(),\
'time':AdaptingVectorQuantity(),\
'positions':AdaptingVectorQuantity(),\
'kinetic_energy':AdaptingVectorQuantity(),\
'potential_energy':AdaptingVectorQuantity(),\
'total_energy':AdaptingVectorQuantity() }
mass_fractions = [0.10, 0.25, 0.50, 0.75]
setattr(data['lagrangianradii'], 'mf', mass_fractions)
data['radius_initial'], data['densities_initial'] = radial_density(\
fi.particles.x, fi.particles.mass, N=10, dim=1)
timerange = numpy.linspace(0, t_end.value_in(t_end.unit),\
n_steps) | t_end.unit
data['time'].extend(timerange)
fi.parameters.timestep = t_end/(n_steps+1)
widget = drawwidget("Evolving")
pbar = pb.ProgressBar(widgets=widget, maxval=len(timerange)).start()
for i, t in enumerate(timerange):
fi.evolve_model(t)
data['kinetic_energy'].append(fi.kinetic_energy)
data['potential_energy'].append(fi.potential_energy)
data['total_energy'].append(fi.total_energy)
data['positions'].append(fi.particles.position)
data['angular_momentum'].append(fi.gas_particles.\
total_angular_momentum())
data['lagrangianradii'].append(fi.particles.LagrangianRadii(\
unit_converter=converter,\
mf=mass_fractions)[0])
if t == timerange[-1] and bodyname:
if os.path.dirname(bodyname) == '':
filename = "bodies/"+bodyname
fi_to_framework.copy()
write_set_to_file(bodies.savepoint(t), filename, "hdf5")
pbar.update(i)
pbar.finish()
data['radius_final'], data['densities_final'] = radial_density(\
fi.particles.x, fi.particles.mass, N=10, dim=1)
fi.stop()
results = HydroResults(data)
return results
def glass(N, target_rms=0.05):
"""
make glass for initial condition generation
"""
if target_rms < 0.001:
print "warning: target_rms highly unlikely to succeed"
L=1| nbody_system.length
dt=0.01 | nbody_system.time
x,y,z=uniform_random_unit_cube(N).make_xyz()
vx,vy,vz=uniform_unit_sphere(N).make_xyz()
p=datamodel.Particles(N)
p.x=L*x
p.y=L*y
p.z=L*z
p.h_smooth=0. * L
p.vx= 0.1*vx | (nbody_system.speed)
p.vy= 0.1*vy | (nbody_system.speed)
p.vz= 0.1*vz | (nbody_system.speed)
p.u= (0.1*0.1) | nbody_system.speed**2
p.mass=(8./N) | nbody_system.mass
sph=Fi(use_gl=False,mode='periodic',redirection='none')
sph.initialize_code()
sph.parameters.use_hydro_flag=True
sph.parameters.radiation_flag=False
sph.parameters.self_gravity_flag=False
sph.parameters.gamma=1
sph.parameters.isothermal_flag=True
sph.parameters.integrate_entropy_flag=False
sph.parameters.timestep=dt
sph.parameters.verbosity=0
sph.parameters.pboxsize=2*L
sph.parameters.artificial_viscosity_alpha = 1.
sph.parameters.beta = 2.
sph.commit_parameters()
sph.gas_particles.add_particles(p)
sph.commit_particles()
# sph.start_viewer()
t=0. | nbody_system.time
rms=1.
i=0
while rms > target_rms:
t=t+(0.25 | nbody_system.time)
sph.evolve_model(t)
h=sph.particles.h_smooth.value_in(nbody_system.length)
rho=h**(-3.)
rms=rho.std()/rho.mean()
print rms, target_rms
x=sph.particles.x.value_in(nbody_system.length)
y=sph.particles.y.value_in(nbody_system.length)
z=sph.particles.z.value_in(nbody_system.length)
sph.stop()
return x,y,z
def run_mc(N=5000,Mcloud=10000. | units.MSun,Rcloud=1. | units.parsec):
conv = nbody_system.nbody_to_si(Mcloud,Rcloud)
interaction_timestep = 0.01 | units.Myr
time_end=0.36 | units.Myr
parts=molecular_cloud(targetN=N,convert_nbody=conv,
base_grid=body_centered_grid_unit_cube).result
sph=Fi(conv)
# need to turn off self gravity, the bridge will calculate this
sph.parameters.self_gravity_flag=False
# some typical Fi flags (just for reference, most are default values)
sph.parameters.use_hydro_flag=True
sph.parameters.isothermal_flag=True
sph.parameters.integrate_entropy_flag=False
sph.parameters.gamma=1
sph.parameters.verbosity = 0
# setting the hydro timestep is important
# the sph code will take 2 timesteps every interaction timestep
sph.parameters.timestep=interaction_timestep/2
sph.gas_particles.add_particles(parts)
def new_code_to_calculate_gravity_of_gas_particles():
result = BHTree(conv)
return result
calculate_gravity_code=bridge.CalculateFieldForCodes(
new_code_to_calculate_gravity_of_gas_particles, # the code that calculates the acceleration field
input_codes = [sph] # the codes to calculate the acceleration field of
)
bridged_system = bridge.Bridge()
bridged_system.timestep=interaction_timestep
bridged_system.add_system(
sph, # the code to move the particles of
[calculate_gravity_code] # the codes that provide the acceleration field
)
fig=pyplot.figure(figsize=(12,12))
ncolumn=2
nrow=2
nplot=ncolumn*nrow
grid_size = 3 | units.parsec
extent = (grid_size * (-0.5, 0.5, -0.5, 0.5)).value_in(units.parsec)
if nplot > 1:
plot_timestep = time_end / (nplot - 1)
else:
plot_timestep = time_end
for i in range(nplot):
ttarget=i*plot_timestep
print("evolving to time:", ttarget.as_quantity_in(units.Myr))
bridged_system.evolve_model(ttarget)
rho=make_map(sph,N=200,grid_size=grid_size)
subplot=fig.add_subplot(ncolumn,nrow,i+1)
subplot.imshow(
numpy.log10(1.e-5+rho.value_in(units.amu/units.cm**3)),
extent = extent,
vmin=1,
vmax=5
)
subplot.set_title(ttarget.as_quantity_in(units.Myr))
sph.stop()
pyplot.show()
