def __getstate__(self):
write_set_to_file(self.particles, self.particlesPath + self.storageFilename, "hdf5")
pickleDict = self.__dict__.copy()
del pickleDict["particles"]
del pickleDict["dialog"]
del pickleDict["ui"]
return pickleDict
def main(tend=30 | units.Myr,
N=10000,
dt=1. | units.Myr,
L=15 | units.kpc,
source_luminosity=5.e48 | units.s**-1,
rhoinit=0.001 | (units.amu / units.cm**3),
Tinit=100. | units.K,
hydro_code=Fi,
rad_code=SPHRay,
write_snapshots=True):
gas, src = iliev_test_5(N=N,
L=L,
source_luminosity=source_luminosity,
rhoinit=rhoinit,
Tinit=Tinit)
converter = nbody_system.nbody_to_si(L**3 * rhoinit, L)
def hydrocode():
return hydro_code(converter, mode='periodic')
def radcode():
return rad_code() #redirection="none")
radhydro = RadiativeHydro(rad=radcode, hydro=hydrocode)
hydro_parameters = suggested_parameter_set[hydro_code]
hydro_parameters['timestep'] = dt / 2
hydro_parameters['periodic_box_size'] = 2 * L
for x in hydro_parameters:
radhydro.hydro_parameters.__setattr__(x, hydro_parameters[x])
radhydro.gas_particles.add_particles(gas)
rad_parameters = suggested_parameter_set[rad_code]
rad_parameters["box_size"] = 2 * L
# rad_parameters["momentum_kicks_flag"]=False
for x in rad_parameters:
radhydro.rad_parameters.__setattr__(x, rad_parameters[x])
radhydro.rad_particles.add_particles(gas)
radhydro.src_particles.add_particles(src)
# radhydro.constant_heating=gas.u/(20.| units.Myr)
t = radhydro.model_time
while t < tend - dt / 2:
t += dt
radhydro.evolve_model(t)
T = T_from_u(radhydro.rad_particles.xion, radhydro.gas_particles.u)
xion = radhydro.rad_particles.xion
rho = radhydro.gas_particles.rho
v = (radhydro.gas_particles.vx**2 + radhydro.gas_particles.vz**2 +
radhydro.gas_particles.vy**2)**0.5
print t.in_(units.Myr),
print "min T:", T.amin().in_(units.K),
print "max T:", T.amax().in_(units.K),
print "min x_ion:", xion.min(),
print "max x_ion:", xion.max(),
print "min v:", v.amin().in_(units.kms),
print "max v:", v.amax().in_(units.kms)
print "min rho:", rho.amin().in_(units.amu / units.cm**3),
print "max rho:", rho.amax().in_(units.amu / units.cm**3)
write_set_to_file(radhydro.radhydro_particles_copy(),
'gas_final',
"amuse",
append_to_file=False)
def write_rad_set(filename, radpart):
write_set_to_file(radpart, filename, "amuse", append_to_file=False)
def simulation(code_name, orbiter_name, potential, Mgalaxy, Rgalaxy, sepBinary,
rvals, phivals, zvals, vrvals, vphivals, vzvals, masses, radii,
Norbiters, tend, dt):
converter_parent = nbody_system.nbody_to_si(Mgalaxy, Rgalaxy)
converter_sub = nbody_system.nbody_to_si(
np.median(masses) | units.MSun,
5. | units.parsec) #masses list is in solar mass units
galaxy_code = to_amuse(potential,
t=0.0,
tgalpy=0.0,
reverse=False,
ro=None,
vo=None)
#first thing is all particles in one superset, gravity is the code,
#third thing is the list of orbiter bodies s.t. we can compute COMs independently
#and plot them with different colors
simulation_bodies, gravity, orbiter_bodies_list, cluster_colors, stellar = gravity_code_setup(
code_name, orbiter_name, Mgalaxy, Rgalaxy, galaxy_code, sepBinary,
rvals, phivals, zvals, vrvals, vphivals, vzvals, masses, radii,
Norbiters)
channel_from_gravity_to_framework = gravity.particles.new_channel_to(
simulation_bodies)
channel_from_framework_to_gravity = simulation_bodies.new_channel_to(
gravity.particles)
channel_from_stellar_to_framework = stellar.particles.new_channel_to(
simulation_bodies)
Ntotal = len(simulation_bodies)
sim_times_unitless = np.arange(
0.,
tend.value_in(units.Myr) + dt.value_in(units.Myr),
dt.value_in(units.Myr))
sim_times = [t | units.Myr for t in sim_times_unitless]
#np.savetxt('times_in_Myr_%s_%s_Norbiters_%i.txt'%(code_name, orbiter_name, Norbiters), sim_times_unitless)
delta_energies, clock_times = [], []
body_masses = gravity.particles.mass
'''
#for 3D numpy array storage
Nsavetimes = 50
all_data = np.zeros((Nsavetimes+1, Ntotal, 6))
mass_data = np.zeros((Nsavetimes+1, Ntotal))
'''
#for saving in write_set_to_file
filename = 'data_temp.csv'
attributes = ('mass', 'x', 'y', 'z', 'vx', 'vy', 'vz')
print('len(sim_times) is', len(sim_times))
#gadget_flag = int(math.floor(len(sim_times)/Nsavetimes))
t0 = time.time()
#j_like_index = 0
for j, t in enumerate(sim_times):
clock_times.append(time.time() - t0) #will be in seconds
'''
if j == 0:
E_dyn_init = gravity.kinetic_energy + gravity.potential_energy
E_dyn = gravity.kinetic_energy + gravity.potential_energy
dE_dyn = (E_dyn/E_dyn_init) - 1.
delta_energies.append(dE_dyn)
if j%gadget_flag == 0:
print_diagnostics(t, simulation_bodies, E_dyn, dE_dyn)
io.write_set_to_file(gravity.particles, filename, 'csv',
attribute_types = (units.MSun, units.kpc, units.kpc, units.kpc, units.kms, units.kms, units.kms),
attribute_names = attributes)
data_t = pd.read_csv(filename, names=list(attributes))
data_t = data_t.drop([0, 1, 2]) #removes labels units, and unit names
masses = data_t['mass'].tolist()
mass_data[j_like_index, :len(data_t.index)] = masses #in solar masses
j_like_index += 1
'''
io.write_set_to_file(gravity.particles,
filename,
'csv',
attribute_types=(units.MSun, units.kpc, units.kpc,
units.kpc, units.kms, units.kms,
units.kms),
attribute_names=attributes)
data_t = pd.read_csv(filename, names=list(attributes))
stellar.evolve_model(t)
channel_from_stellar_to_framework.copy()
channel_from_framework_to_gravity.copy()
gravity.evolve_model(t)
channel_from_gravity_to_framework.copy()
np.savetxt(
code_name + '_' + orbiter_name + '_masses_Norbiters_' +
str(Norbiters) + '_dt_' + str(dt.value_in(units.Myr)) + '.txt',
mass_data)
return 0
def simulation(code_name, orbiter_name, potential, Mgalaxy, Rgalaxy, sepBinary,
rvals, phivals, zvals, vrvals, vphivals, vzvals, masses, radii,
Norbiters, tend, dt):
converter_parent = nbody_system.nbody_to_si(Mgalaxy, Rgalaxy)
converter_sub = nbody_system.nbody_to_si(
np.median(masses) | units.MSun,
5. | units.parsec) #masses list is in solar mass units
galaxy_code = to_amuse(potential,
t=0.0,
tgalpy=0.0,
reverse=False,
ro=None,
vo=None)
#first thing is all particles in one superset, gravity is the code,
#third thing is the list of orbiter bodies s.t. we can compute COMs independently
#and plot them with different colors
simulation_bodies, gravity, orbiter_bodies_list, cluster_colors, stellar = gravity_code_setup(
code_name, orbiter_name, Mgalaxy, Rgalaxy, galaxy_code, sepBinary,
rvals, phivals, zvals, vrvals, vphivals, vzvals, masses, radii,
Norbiters)
#channel_from_gravity_to_framework = gravity.particles.new_channel_to(simulation_bodies)
#channel_from_framework_to_gravity = simulation_bodies.new_channel_to(gravity.particles)
channel_from_stellar_to_framework = stellar.particles.new_channel_to(
simulation_bodies)
Ntotal = len(simulation_bodies)
sim_times_unitless = np.arange(
0.,
tend.value_in(units.Myr) + dt.value_in(units.Myr),
dt.value_in(units.Myr))
sim_times = [t | units.Myr for t in sim_times_unitless]
#np.savetxt('times_in_Myr_%s_%s_Norbiters_%i.txt'%(code_name, orbiter_name, Norbiters), sim_times_unitless)
delta_energies, clock_times = [], []
body_masses = gravity.particles.mass
'''
if orbiter_name == 'SingleStar':
cluster_populations = [1 for i in range(Norbiters) ]
'''
if orbiter_name == 'SingleCluster':
#cluster_populations = np.loadtxt('/home/s1780638/second_project_gcs/data/Nstars_in_clusters.txt')
cluster_populations = np.loadtxt(
'/home/brian/Desktop/second_project_gcs/data/Nstars_in_clusters.txt'
)
#need to give clusters sorted by an attribute, in our case increasing |r|
#new_index = indices_dict[old_index]
indices_dict = sort_clusters_by_attribute('|r|')
cluster_populations_sorted = [
cluster_populations[indices_dict[i]] for i in range(Norbiters)
]
#for 3D numpy array storage
Nsavetimes = 50
all_data = np.zeros((Nsavetimes + 1, Ntotal, 6))
mass_data = np.zeros((Nsavetimes + 1, Ntotal))
#COM_data = np.zeros((len(sim_times), Norbiters, 2))
#for saving in write_set_to_file
filename = 'data_temp.csv'
attributes = ('mass', 'x', 'y', 'z', 'vx', 'vy', 'vz')
print('len(sim_times) is', len(sim_times))
gadget_flag = int(math.floor(len(sim_times) / Nsavetimes))
t0 = time.time()
j_like_index = 0
for j, t in enumerate(sim_times):
clock_times.append(time.time() - t0) #will be in seconds
if j == 0:
E_dyn_init = gravity.kinetic_energy + gravity.potential_energy
E_dyn = gravity.kinetic_energy + gravity.potential_energy
dE_dyn = (E_dyn / E_dyn_init) - 1.
delta_energies.append(dE_dyn)
if j % gadget_flag == 0:
print_diagnostics(t, simulation_bodies, E_dyn, dE_dyn)
io.write_set_to_file(
gravity.particles,
filename,
'csv',
attribute_types=(units.MSun, units.kpc, units.kpc, units.kpc,
units.kms, units.kms, units.kms),
attribute_names=attributes)
data_t = pd.read_csv(filename, names=list(attributes))
data_t = data_t.drop([0, 1,
2]) #removes labels units, and unit names
masses = data_t['mass'].tolist()
mass_data[
j_like_index, :len(data_t.index)] = masses #in solar masses
'''
data_t = data_t.drop(columns=['mass']) #goes from 7D --> 6D
data_t = data_t.astype(float) #strings to floats
all_data[j_like_index, :len(data_t.index), :] = data_t.values
np.savetxt('enbid_%s_frame_%s_Norbiters_%s.ascii'%(code_name, str(j).rjust(5, '0'), str(Norbiters)), data_t.values)
x, y = data_t['x'].tolist(), data_t['y'].tolist()
#stuff to analyze COM of each star cluster
for k, number_of_stars in enumerate(cluster_populations_sorted):
starting_index = int(np.sum( cluster_populations_sorted[:k] ))
ending_index = starting_index + int(number_of_stars)
cluster_masses = body_masses[starting_index:ending_index]
cluster_total_mass = cluster_masses.sum()
x_COM = np.sum( [ body_masses[i]*x[i]/cluster_total_mass for i in range(starting_index, ending_index) ] ) #in kpc
y_COM = np.sum( [ body_masses[i]*y[i]/cluster_total_mass for i in range(starting_index, ending_index) ] ) #in kpc
COM_data[j_like_index, k, 0] = x_COM
COM_data[j_like_index, k, 1] = y_COM
'''
j_like_index += 1
stellar.evolve_model(t)
channel_from_stellar_to_framework.copy()
#channel_from_framework_to_gravity.copy()
#gravity.evolve_model(t)
#channel_from_gravity_to_framework.copy()
#try:
# gravity.stop()
#except:
# print('gravity cannot be stopped, mwahahaha')
np.savetxt(
code_name + '_' + orbiter_name + '_masses_Norbiters_' +
str(Norbiters) + '_dt_' + str(dt.value_in(units.Myr)) + '.txt',
mass_data)
#np.savetxt(code_name + '_' + orbiter_name + '_colors_Norbiters_' + str(Norbiters) + '_dt_' + str(dt.value_in(units.Myr)) + '.txt', cluster_colors)
#np.savetxt(code_name + '_' + orbiter_name + '_dE_Norbiters_' + str(Norbiters) + '_dt_' + str(math.floor(dt.value_in(units.Myr)*1000)).rjust(5, '0') + '.txt', delta_energies)
#np.savetxt(code_name + '_' + orbiter_name + '_dt_' + str(dt.value_in(units.Myr)) + '.txt''_clock_times.txt', clock_times)
return 0
def main(
Ngas=args.Ngas,
tend=args.tend | units.Myr,
dt=args.dt | units.Myr,
Lbox=30.0 | units.kpc,
Lsrc=5.e48 | units.s**-1,
rho_init=1.0e-3 | (units.amu / units.cm**3),
T_init=1.0e2 | units.K,
rad_code=SPHRay,
#rad_code = SimpleXSplitSet,
hydro_code=Fi,
write_snapshots=True):
# report to screen
#---------------------------------------------------------------------
print
print 'Iliev 09 Test 5'
print 'Ngas: ', Ngas
print 'tend: ', tend
print 'dt: ', dt
print 'Lbox: ', Lbox
print 'Lsrc: ', Lsrc
print 'rho_init: ', rho_init
print 'T_init: ', T_init
print 'rad code: ', rad_code
print 'hydro code: ', hydro_code
print
# set up gas and source particles
#---------------------------------------------------------------------
(gas, src) = set_gas_and_src(Ngas, Lbox, Lsrc, rho_init, T_init)
print 'gas x min/max: ', gas.x.min().value_in( units.kpc ), \
gas.x.max().value_in( units.kpc )
print 'gas y min/max: ', gas.y.min().value_in( units.kpc ), \
gas.y.max().value_in( units.kpc )
print 'gas z min/max: ', gas.z.min().value_in( units.kpc ), \
gas.z.max().value_in( units.kpc )
print 'gas vx min/max: ', gas.vx.min().value_in( units.km/units.s ), \
gas.vx.max().value_in( units.km/units.s )
print 'gas vy min/max: ', gas.vy.min().value_in( units.km/units.s ), \
gas.vy.max().value_in( units.km/units.s )
print 'gas vz min/max: ', gas.vz.min().value_in( units.km/units.s ), \
gas.vz.max().value_in( units.km/units.s )
print
# set up a system of units in which G=1. the function takes any two
# fundamental dimensions (in this case mass and length) and calculates
# the third such that G = 1.
#---------------------------------------------------------------------
converter = nbody_system.nbody_to_si(Lbox**3 * rho_init, Lbox)
# initialize the radhydro class
#---------------------------------------------------------------------
def hydrocode():
return hydro_code(converter, mode='periodic')
def radcode():
return rad_code()
radhydro = RadiativeHydro(rad=radcode, hydro=hydrocode)
# set hydro code parameters
#---------------------------------------------------------------------
hydro_parameters = suggested_parameter_set[hydro_code]
hydro_parameters['timestep'] = dt / 2
for x in hydro_parameters:
radhydro.hydro_parameters.__setattr__(x, hydro_parameters[x])
radhydro.gas_particles.add_particles(gas)
# set rad code parameters
#---------------------------------------------------------------------
rad_parameters = suggested_parameter_set[rad_code]
if rad_code == SPHRay:
rad_parameters["momentum_kicks_flag"] = False
for x in rad_parameters:
radhydro.rad_parameters.__setattr__(x, rad_parameters[x])
radhydro.rad_particles.add_particles(gas)
radhydro.src_particles.add_particles(src)
# evolve system
#---------------------------------------------------------------------
t = radhydro.model_time
while t < tend - dt / 2:
t += dt
radhydro.evolve_model(t)
T = T_from_u(radhydro.rad_particles.xion, radhydro.gas_particles.u)
xion = radhydro.rad_particles.xion
v = (radhydro.gas_particles.vx**2 + radhydro.gas_particles.vz**2 +
radhydro.gas_particles.vy**2)**0.5
print t.in_(units.Myr)
print "min/max T:", T.amin().in_(units.K), T.amax().in_(units.K)
print "min/max x_ion:", xion.min(), xion.max()
print "min/max v:", v.amin().in_(units.kms), v.amax().in_(units.kms)
print
# check if we've reached an output time
#--------------------------------------------------------
if write_snapshots:
t_now = t.value_in(units.Myr)
t_lbl = t.value_in(units.Myr) * 1000
fname = "output/iliev5-%7.7i" % int(t_lbl)
for t_check in OUT_TIMES:
t_diff = numpy.abs((t_now - t_check))
if t_diff < OUTPUT_TIME_TOL:
# function combines data from hydro particles
# and radiation particles
gas_particles = radhydro.radhydro_particles_copy()
write_set_to_file(gas_particles,
fname,
"amuse",
append_to_file=False)
plot_iliev5.plot_profiles(data=gas_particles, t=t)
plot_iliev5.plot_images(data=gas_particles, t=t)
def write_combined_set(filename, hydropart, radpart):
p = radpart.copy()
channel = hydropart.new_channel_to(p)
channel.copy_attributes(
["mass", "x", "y", "z", "vx", "vy", "vz", "rho", "u"])
write_set_to_file(p, filename, "amuse", append_to_file=False)