def get_6D_fw(points, values, uniformity, Norbiters):
#datadir = '/home/s1780638/second_project_GCs/data/'
datadir = '/Users/BrianTCook/Desktop/Thesis/second_project_GCs/data/'
cluster_populations = list(np.loadtxt(datadir + '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 = [
int(cluster_populations[indices_dict[i]]) for i in range(Norbiters)
]
grids = lattices_maker(points, uniformity, Norbiters)
fw_values_interpolated = []
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)
X, Y, Z, VX, VY, VZ = np.meshgrid(*grids[k])
#Ti is 6-D interpolation using method=method
grid_z0 = griddata(points[starting_index:ending_index, :],
values[starting_index:ending_index],
(X, Y, Z, VX, VY, VZ),
method='nearest')
fw_values_interpolated.append(grid_z0)
return fw_values_interpolated
def lattices_maker(points, uniformity, Norbiters):
'''
takes 6D phase space coordinates
tessellates phase space s.t. there are < Npoints_max
'''
#datadir = '/home/s1780638/second_project_GCs/data/'
datadir = '/Users/BrianTCook/Desktop/Thesis/second_project_GCs/data/'
cluster_populations = list(np.loadtxt(datadir + '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 = [
int(cluster_populations[indices_dict[i]]) for i in range(Norbiters)
]
grids = []
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)
xvals, yvals, zvals = points[starting_index:ending_index, 0], points[
starting_index:ending_index,
1], points[starting_index:ending_index, 2]
vxvals, vyvals, vzvals = points[
starting_index:ending_index,
3], points[starting_index:ending_index,
4], points[starting_index:ending_index, 5]
if uniformity == 'uniform':
Ncells = 8
x_spatial = np.linspace(min(xvals), max(xvals), Ncells)
y_spatial = np.linspace(min(yvals), max(yvals), Ncells)
z_spatial = np.linspace(min(zvals), max(zvals), Ncells)
x_velocity = np.linspace(min(vxvals), max(vxvals), Ncells)
y_velocity = np.linspace(min(vyvals), max(vyvals), Ncells)
z_velocity = np.linspace(min(vzvals), max(vzvals), Ncells)
grids.append([
x_spatial, y_spatial, z_spatial, x_velocity, y_velocity, z_velocity
])
return grids
def get_entropy(points, values, uniformity, Norbiters):
'''
right now have N x N x N x N x N x N array
need to integrate s.t. we get a 1 x 1 x 1 x 1 x 1 x 1 array
the value within it will be the information entropy
'''
#datadir = '/home/s1780638/second_project_GCs/data/'
datadir = '/Users/BrianTCook/Desktop/Thesis/second_project_GCs/data/'
cluster_populations = list(np.loadtxt(datadir + '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 = [
int(cluster_populations[indices_dict[i]]) for i in range(Norbiters)
]
fw_values_interpolated = get_6D_fw(points, values, uniformity, Norbiters)
grids = lattices_maker(points, uniformity, Norbiters)
#S = 0 #entropy
entropies = []
for k, number_of_stars in enumerate(cluster_populations_sorted):
if k <= 7:
integral = simpson_6D(grids[k], fw_values_interpolated[k])
entropies.append(-integral)
#S -= integral
#returns entropy
#return S
return entropies
def get_kmeans_result(snapshots, Norbiters, initial_masses):
t0 = time.time()
datadir = '/Users/BrianTCook/Desktop/Thesis/second_project_GCs/data/'
datadir_AMUSE = '/Users/BrianTCook/Desktop/Thesis/second_project_GCs/Enbid-2.0/AMUSE_data/'
cluster_populations = np.loadtxt(datadir + 'Nstars_in_clusters.txt')
cluster_radii = np.loadtxt(datadir + '/ICs/cluster_radii_for_sampling.txt')
indices_dict, cluster_masses, cluster_dists = sort_clusters_by_attribute(
'|r|')
cluster_populations_sorted = [
cluster_populations[indices_dict[i]] for i in range(Norbiters)
]
cluster_radii_sorted = [
cluster_radii[indices_dict[i]] for i in range(Norbiters)
]
cluster_masses_sorted = [
cluster_masses[indices_dict[i]] for i in range(Norbiters)
]
cluster_dists_sorted = [
cluster_dists[indices_dict[i]] for i in range(Norbiters)
]
true_labels = []
for i in range(Norbiters):
true_labels += [i for j in range(int(cluster_populations_sorted[i]))]
delta_max = 0.9
all_deltas = [[] for i in range(Norbiters)]
endpoints = ['' for i in range(Norbiters)]
active_orbiters = [i for i in range(Norbiters)]
star_masses = np.loadtxt(
datadir +
'tree_data/tree_SingleCluster_masses_Norbiters_64_dt_0.2.txt').T
deltaMs = np.zeros(star_masses[0, :].shape)
for i in range(1, len(deltaMs)):
deltaMs[i] = np.mean(star_masses[:, i]) - np.mean(star_masses[:,
i - 1])
deltaM = np.mean(deltaMs)
for k, snapshot in enumerate(snapshots):
print(snapshot)
print('time is: %.03f minutes' % ((time.time() - t0) / 60.))
if len(active_orbiters) == 0:
return all_deltas, endpoints
data_filename = glob.glob(datadir_AMUSE + '*_%s_Norbiters_%i.ascii' %
(snapshot, Norbiters))
data_3D = np.loadtxt(data_filename[0])[:, :3]
df = pd.DataFrame(data_3D, columns=['x', 'y', 'z'])
df['labels'] = true_labels
star_masses_truncated = star_masses[:len(df.index), k]
df['masses'] = star_masses_truncated
for cluster_label in active_orbiters:
#print('cluster_label: ', cluster_label)
#print('current time: %.04f minutes'%((time.time()-t0)/60.))
df_cluster = df.loc[df['labels'] == cluster_label]
df_cluster['separation distance'] = '' #in parsecs
m_cluster_init = cluster_masses_sorted[cluster_label]
#sort by distance from COM of cluster
xc, yc, zc = np.median(df_cluster['x'].tolist()), np.median(
df_cluster['y'].tolist()), np.median(df_cluster['z'].tolist())
for i in df_cluster.index:
dist_sq = (df_cluster.at[i, 'x'] -
xc)**2 + (df_cluster.at[i, 'y'] -
yc)**2 + (df_cluster.at[i, 'z'] - zc)**2
dist_in_pc = np.sqrt(dist_sq) * 1000.
df_cluster.loc[i, 'separation distance'] = dist_in_pc
#praint('median separation distance, initial radius: %.03f pc, %.03f pc'%(np.median(df_cluster['separation distance'].tolist()), cluster_radii_sorted[cluster_label] ))
df_cluster = df_cluster[
df_cluster['separation distance'] <= 2. * cluster_radii_sorted[
cluster_label]] #outside of original radius
df_cluster = df_cluster.reset_index(drop=True)
m_cluster_t = np.sum(df_cluster['masses'].tolist())
nstars = len(df_cluster.index)
'''
add column saying current label for plot showing N_in birth cluster,
N_field, and N_adopted by other cluster?
'''
if len(df_cluster.index) != 0:
m_cluster_t = np.sum(df_cluster['masses'].tolist())
eps = nstars * deltaM / m_cluster_t
delta = 1. - m_cluster_t / m_cluster_init * (1 + eps)
galactocentric_dist = np.sqrt(
np.median(df_cluster['x'].tolist())**2. +
np.median(df_cluster['y'].tolist())**2. +
np.median(df_cluster['z'].tolist())**2.)
endpoints[
cluster_label] = 'final galactocentric distance: %.03f kpc' % (
galactocentric_dist)
else:
delta = 1.
all_deltas[cluster_label].append(delta)
if delta >= delta_max:
endpoints[cluster_label] = 'disruption time: %.00f Myr' % (k *
2.)
active_orbiters.remove(
cluster_label) #removes orbiter label from active ones
return all_deltas, endpoints, cluster_dists_sorted
def orbiter(code_name, orbiter_name, Mgalaxy, Rgalaxy, sepBinary, rvals,
phivals, zvals, vrvals, vphivals, vzvals, masses, index):
#need to give clusters sorted by an attribute, in our case increasing |r|
#sorting needs to happen once, either here or in star_cluster function
indices_dict = sort_clusters_by_attribute('|r|')
index_sorted = indices_dict[index]
#data_directory = '/home/s1780638/second_project_gcs/data/'
data_directory = '/home/brian/Desktop/second_project_gcs/data/'
star_masses = np.loadtxt(data_directory +
'star_masses/star_masses_index=%s.txt' %
(str(index_sorted)))
radius = np.loadtxt(data_directory +
'/ICs/cluster_radii_for_sampling.txt')[index_sorted]
converter_parent = nbody_system.nbody_to_si(Mgalaxy, Rgalaxy)
converter_sub = nbody_system.nbody_to_si(
np.sum(star_masses) | units.MSun,
radius | units.parsec) #masses list is in solar mass units
'''
takes in R, Z value
returns VR, Vphi, VZ values
should get appropriate 6D initial phase space conditions
'''
r_init, phi_init, z_init = rvals[index_sorted], phivals[
index_sorted], zvals[index_sorted]
vr_init, vphi_init, vz_init = vrvals[index_sorted], vphivals[
index_sorted], vzvals[index_sorted]
#convert from galpy/cylindrical to AMUSE/Cartesian units
x_init = r_init * np.cos(phi_init) | units.kpc
y_init = r_init * np.sin(phi_init) | units.kpc
z_init = z_init | units.kpc
#vphi = R \dot{\phi}? assuming yes for now
vx_init = (vr_init * np.cos(phi_init) -
vphi_init * np.sin(phi_init)) | units.kms
vy_init = (vr_init * np.sin(phi_init) +
vphi_init * np.cos(phi_init)) | units.kms
vz_init = vz_init | units.kms
if orbiter_name == 'SingleStar':
bodies = Particles(1)
bodies[0].mass = 1 | units.MSun
#right place in phase space
bodies[0].x = x_init
bodies[0].y = y_init
bodies[0].z = z_init
bodies[0].vx = vx_init
bodies[0].vy = vy_init
bodies[0].vz = vz_init
#sub_worker in Nemesis, should not matter for SingleStar
if code_name == 'Nbody':
code = Hermite(converter_sub) #Mercury acts weird for SingleStar
code.particles.add_particles(bodies)
code.commit_particles()
if code_name == 'tree' or code_name == 'nemesis':
#definition of gravity_code takes care of nemesis
code = BHTree(converter_sub)
code.particles.add_particles(bodies)
code.commit_particles()
return bodies, code
if orbiter_name == 'SingleCluster':
bodies, code, _ = star_cluster(rvals, phivals, zvals, vrvals, vphivals,
vzvals, masses, radius, index_sorted,
Mgalaxy, Rgalaxy, code_name)
return bodies, code
def maps(whole_or_clusters):
datadir_AMUSE = '/Users/BrianTCook/Desktop/Thesis/second_project_gcs/Enbid-2.0/AMUSE_data/'
logN_max = 6
Norbiters_list = [2**6] #int(2**i) for i in range(logN_max)]
datadir = '/Users/BrianTCook/Desktop/Thesis/second_project_GCs/data/'
cluster_populations_raw = np.loadtxt(datadir + 'Nstars_in_clusters.txt')
indices_dict, df_sorted_by_r = sort_clusters_by_attribute('|r|')
cluster_populations_sorted = [
cluster_populations_raw[indices_dict[i]] for i in range(2**logN_max)
]
x_init_all = df_sorted_by_r['x'].tolist()
y_init_all = df_sorted_by_r['y'].tolist()
z_init_all = df_sorted_by_r['z'].tolist()
vx_init_all = df_sorted_by_r['vx'].tolist()
vy_init_all = df_sorted_by_r['vy'].tolist()
vz_init_all = df_sorted_by_r['vz'].tolist()
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.style.use('dark_background')
sim_times = np.linspace(0., 100., 51)
gadget_flags = [0, 25, 50]
for Norbiters in Norbiters_list:
cluster_populations = list(cluster_populations_sorted)[:Norbiters]
if whole_or_clusters == 'whole':
#plot whole picture in (x,z) plane
fig, axs = plt.subplots(3, 1)
l = 0
for i, t in enumerate(sim_times):
if i in gadget_flags:
print('time: %.02f Myr' % (t))
phase_space_data = np.loadtxt(
datadir_AMUSE +
'enbid_tree_frame_%s_Norbiters_%i.ascii' %
(str(i * 10).rjust(5, '0'), Norbiters))
y_total = phase_space_data[:, 0]
z_total = phase_space_data[:, 2]
ytotztot = np.vstack([y_total, z_total])
colortot = gaussian_kde(ytotztot)(ytotztot)
idx = colortot.argsort()
y_tot, z_tot, colors = y_total[idx], z_total[
idx], colortot[idx]
cm = plt.cm.get_cmap('plasma')
axs[l].scatter(y_tot,
z_tot,
marker=',',
s=0.1,
c=colors,
cmap=cm,
linewidths=0)
axs[l].annotate(r'$t_{\mathrm{sim}} = %.02f$ Myr' % (t),
xy=(0.1, 0.85),
xycoords='axes fraction',
fontsize=6)
#fig.colorbar(sc, fraction=0.046, pad=0.04)#, norm=LogNorm())
axs[l].set_xlim(-2.0, 2.0)
axs[l].set_xticks([-1.5, 0., 1.5])
axs[l].set_ylim(-1.0, 1.0)
axs[l].set_yticks([-0.5, 0., 0.5])
axs[l].set_aspect('equal')
axs[l].tick_params(labelsize='small')
axs[l].set_xlabel(r'$y$ (kpc)', fontsize=10)
axs[l].set_ylabel(r'$z$ (kpc)', fontsize=10)
l += 1
# Hide x labels and tick labels for top plots and y ticks for right plots.
for ax in axs.flat:
ax.label_outer()
#plt.suptitle(r'$\log_{2}N_{\mathrm{clusters}}=6$ Simulation', fontsize=12)
plt.subplots_adjust(wspace=0, hspace=0)
plt.savefig('snapshot_Norbiters_%s_all.jpg' % (str(Norbiters)),
bbox_inches='tight')
plt.close()
if whole_or_clusters == 'clusters':
N = 8 #total number of initialized clusters I have
dim_array_naive = np.loadtxt(
datadir +
'manifold_dimensions/dim_array_naive_Norbiters_%i.txt' % (N))
dim_array_pca = np.loadtxt(
datadir +
'manifold_dimensions/dim_array_pca_Norbiters_%i.txt' % (N))
for i, t in enumerate(sim_times):
if i in gadget_flags:
phase_space_data = np.loadtxt(
datadir_AMUSE +
'enbid_tree_frame_%s_Norbiters_%i.ascii' %
(str(i * 10).rjust(5, '0'), Norbiters))
for k, number_of_stars in enumerate(cluster_populations):
if k < 10 or k > 53:
print('Index: %i' % (k))
starting_index = int(
np.sum(cluster_populations[:k]))
ending_index = starting_index + int(
number_of_stars)
x_init = x_init_all[k]
y_init = y_init_all[k]
z_init = z_init_all[k]
vx_init = vx_init_all[k]
vy_init = vy_init_all[k]
vz_init = vz_init_all[k]
x = phase_space_data[starting_index:ending_index,
0]
y = phase_space_data[starting_index:ending_index,
1]
z = phase_space_data[starting_index:ending_index,
2]
vx = phase_space_data[starting_index:ending_index,
3]
vy = phase_space_data[starting_index:ending_index,
4]
vz = phase_space_data[starting_index:ending_index,
5]
x = np.asarray([xx - x_init for xx in x])
y = np.asarray([yy - y_init for yy in y])
z = np.asarray([zz - z_init for zz in z])
vx = np.asarray([vxvx - vx_init for vxvx in vx])
vy = np.asarray([vyvy - vy_init for vyvy in vy])
vz = np.asarray([vzvz - vz_init for vzvz in vz])
dx = (np.percentile(x, 95) -
np.percentile(x, 5)) / 2.
dy = (np.percentile(y, 95) -
np.percentile(y, 5)) / 2.
dz = (np.percentile(z, 95) -
np.percentile(z, 5)) / 2.
dvx = (np.percentile(vx, 95) -
np.percentile(vx, 5)) / 2.
dvy = (np.percentile(vy, 95) -
np.percentile(vy, 5)) / 2.
dvz = (np.percentile(vz, 95) -
np.percentile(vz, 5)) / 2.
fig, axs = plt.subplots(5, 5)
#first column
xy = np.vstack([x, y])
z00 = gaussian_kde(xy)(xy)
idx = z00.argsort()
x, y, colors = x[idx], y[idx], z00[idx]
axs[0, 0].scatter(x,
y,
s=0.5,
c=colors,
edgecolor='')
axs[0, 0].set_ylabel(r'$y$ (kpc)', fontsize=8)
axs[0, 0].tick_params(labelsize='xx-small')
axs[0, 0].set_title(r'$x = %.03f \pm %.03f$ kpc' %
(np.median(x), dx),
fontsize=3)
xz = np.vstack([x, z])
z10 = gaussian_kde(xz)(xz)
idx = z10.argsort()
x, z, colors = x[idx], z[idx], z10[idx]
axs[1, 0].scatter(x,
z,
s=0.5,
c=colors,
edgecolor='')
axs[1, 0].set_ylabel(r'$z$ (kpc)', fontsize=8)
axs[1, 0].tick_params(labelsize='xx-small')
xvx = np.vstack([x, vx])
z20 = gaussian_kde(xvx)(xvx)
idx = z20.argsort()
x, vx, colors = x[idx], vx[idx], z20[idx]
axs[2, 0].scatter(x,
vx,
s=0.5,
c=colors,
edgecolor='')
axs[2, 0].set_ylabel(r'$v_{x}$ (km/s)', fontsize=8)
axs[2, 0].tick_params(labelsize='xx-small')
xvy = np.vstack([x, vy])
z30 = gaussian_kde(xvy)(xvy)
idx = z30.argsort()
x, vy, colors = x[idx], vy[idx], z30[idx]
axs[3, 0].scatter(x,
vy,
s=0.5,
c=colors,
edgecolor='')
axs[3, 0].set_ylabel(r'$v_{y}$ (km/s)', fontsize=8)
axs[3, 0].tick_params(labelsize='xx-small')
xvy = np.vstack([x, vz])
z40 = gaussian_kde(xvy)(xvy)
idx = z40.argsort()
x, vz, colors = x[idx], vz[idx], z40[idx]
axs[4, 0].scatter(x,
vz,
s=0.5,
c=colors,
edgecolor='')
axs[4, 0].set_xlabel(r'$x$ (kpc)', fontsize=8)
axs[4, 0].set_ylabel(r'$v_{z}$ (km/s)', fontsize=8)
axs[4, 0].tick_params(labelsize='xx-small')
#second column
axs[0, 1].axis('off')
yz = np.vstack([y, z])
z11 = gaussian_kde(yz)(yz)
idx = z11.argsort()
y, z, colors = y[idx], z[idx], z11[idx]
axs[1, 1].scatter(y,
z,
s=0.5,
c=colors,
edgecolor='')
axs[1, 1].tick_params(labelsize='xx-small')
axs[1, 1].set_title(r'$y = %.03f \pm %.03f$ kpc' %
(np.median(y), dy),
fontsize=3)
yvx = np.vstack([y, vx])
z21 = gaussian_kde(yvx)(yvx)
idx = z21.argsort()
y, vx, colors = y[idx], vx[idx], z21[idx]
axs[2, 1].scatter(y,
vx,
s=0.5,
c=colors,
edgecolor='')
axs[2, 1].tick_params(labelsize='xx-small')
yvy = np.vstack([y, vy])
z31 = gaussian_kde(yvy)(yvy)
idx = z31.argsort()
y, vy, colors = y[idx], vy[idx], z31[idx]
axs[3, 1].scatter(y,
vy,
s=0.5,
c=colors,
edgecolor='')
axs[3, 1].tick_params(labelsize='xx-small')
yvz = np.vstack([y, vx])
z41 = gaussian_kde(yvz)(yvz)
idx = z41.argsort()
y, vz, colors = y[idx], vz[idx], z41[idx]
axs[4, 1].scatter(y,
vz,
s=0.5,
c=colors,
edgecolor='')
axs[4, 1].set_xlabel(r'$y$ (kpc)', fontsize=8)
axs[4, 1].tick_params(labelsize='xx-small')
#third column
axs[0, 2].axis('off')
axs[1, 2].axis('off')
zvx = np.vstack([z, vx])
z22 = gaussian_kde(zvx)(zvx)
idx = z22.argsort()
z, vx, colors = z[idx], vx[idx], z22[idx]
axs[2, 2].scatter(z,
vx,
s=0.5,
c=colors,
edgecolor='')
axs[2, 2].tick_params(labelsize='xx-small')
axs[2, 2].set_title(r'$z = %.03f \pm %.03f$ kpc' %
(np.median(z), dz),
fontsize=3)
zvy = np.vstack([z, vy])
z32 = gaussian_kde(zvy)(zvy)
idx = z32.argsort()
z, vy, colors = z[idx], vy[idx], z32[idx]
axs[3, 2].scatter(z,
vy,
s=0.5,
c=colors,
edgecolor='')
axs[3, 2].tick_params(labelsize='xx-small')
zvz = np.vstack([z, vz])
z42 = gaussian_kde(zvz)(zvz)
idx = z42.argsort()
z, vz, colors = z[idx], vz[idx], z42[idx]
axs[4, 2].scatter(z,
vz,
s=0.5,
c=colors,
edgecolor='')
axs[4, 2].set_xlabel(r'$z$ (kpc)', fontsize=8)
axs[4, 2].tick_params(labelsize='xx-small')
#fourth column
axs[0, 3].axis('off')
axs[1, 3].axis('off')
axs[2, 3].axis('off')
vxvy = np.vstack([vx, vy])
z33 = gaussian_kde(vxvy)(vxvy)
idx = z33.argsort()
vx, vy, colors = vx[idx], vy[idx], z33[idx]
axs[3, 3].scatter(vx,
vy,
s=0.5,
c=colors,
edgecolor='')
axs[3, 3].tick_params(labelsize='xx-small')
axs[3, 3].set_title(
r'$v_{x} = %.03f \pm %.03f$ km/s' %
(np.median(vx), dvx),
fontsize=3)
vxvz = np.vstack([vx, vz])
z43 = gaussian_kde(vxvz)(vxvz)
idx = z43.argsort()
vx, vz, colors = vx[idx], vz[idx], z43[idx]
axs[4, 3].scatter(vx,
vz,
s=0.5,
c=colors,
edgecolor='')
axs[4, 3].set_xlabel(r'$v_{x}$ (km/s)', fontsize=8)
axs[4, 3].tick_params(labelsize='xx-small')
#fifth column
axs[0, 4].axis('off')
axs[1, 4].axis('off')
axs[2, 4].axis('off')
axs[3, 4].axis('off')
vyvz = np.vstack([vy, vz])
z44 = gaussian_kde(vyvz)(vyvz)
idx = z44.argsort()
vx, vz, colors = vy[idx], vz[idx], z44[idx]
axs[4, 4].scatter(vy,
vz,
s=0.5,
c=colors,
edgecolor='')
axs[4, 4].set_xlabel(r'$v_{y}$ (km/s)', fontsize=8)
axs[4, 4].tick_params(labelsize='xx-small')
axs[4, 4].set_title(
r'$v_{y} = %.03f \pm %.03f$ km/s' %
(np.median(vy), dvy),
fontsize=3)
# Hide x labels and tick labels for top plots and y ticks for right plots.
for ax in axs.flat:
ax.label_outer()
axs[4, 4].set_ylabel(
r'$v_{z} = %.03f \pm %.03f$ km/s' %
(np.median(vz), dvz),
fontsize=3,
rotation=270,
labelpad=12)
axs[4, 4].yaxis.set_label_position("right")
Dn, Dp = dim_array_naive[k, i], dim_array_pca[k, i]
fig.align_ylabels(axs[:, 0])
fig.suptitle(
r'Cluster %i ($D_{\mathrm{naive}, \mathrm{pca}} = %i, %i$,), $t_{\mathrm{sim}}$ = %.00f Myr, Cluster Frame'
% (k, Dn, Dp, t),
fontsize=10)
plt.savefig(
'phase_space_map_frame_%s_Norbiters_%s_Index_%i_internal.pdf'
%
(str(i * 10).rjust(5, '0'), str(Norbiters), k))
plt.close()
return 0
return dimension_array
if __name__ in '__main__':
code_name = 'tree'
tend, dt = 100., 0.2
sim_times_unitless = np.arange(0., tend+dt, dt)
logN_max = 6
Norbiters_list = [ 2**6 ] #for i in range(logN_max+1) ]
datadir = '/Users/BrianTCook/Desktop/Thesis/second_project_GCs/data/'
cluster_populations_raw = np.loadtxt(datadir+'Nstars_in_clusters.txt')
indices_dict = sort_clusters_by_attribute('|r|')
cluster_populations_sorted = [ cluster_populations_raw[indices_dict[i]] for i in range(2**logN_max) ]
rs = np.loadtxt(datadir+'ICs/dehnen_rvals.txt')
phis = np.loadtxt(datadir+'ICs/dehnen_phivals.txt')
zs = np.loadtxt(datadir+'ICs/dehnen_zvals.txt')
vrs = np.loadtxt(datadir+'ICs/bovy_vrvals.txt')
vphis = np.loadtxt(datadir+'ICs/bovy_vphivals.txt')
vzs = np.loadtxt(datadir+'ICs/bovy_vzvals.txt')
N = 2**logN_max #total number of initialized clusters I have
#convert from galpy/cylindrical to AMUSE/Cartesian units
#all in kpc
xs = [ rs[i] * np.cos(phis[i]) for i in range(N) ]