def find_voids(snapshot, ptypes, grid, MAS, do_RSD, axis, threshold, Radii,
threads1, threads2, fout):
# read snapshot header and obtain BoxSize and redshift
head = readgadget.header(snapshot)
BoxSize = head.boxsize/1e3 #Mpc/h
redshift = head.redshift
# compute density field
delta = MASL.density_field_gadget(snapshot, ptypes, grid, MAS, do_RSD, axis)
delta /= np.mean(delta, dtype=np.float64); delta -= 1.0
# identify voids
V = VL.void_finder(delta, BoxSize, threshold, Radii,
threads1, threads2, void_field=False)
# void properties and void size function
void_pos = V.void_pos
void_radius = V.void_radius
VSF_R = V.Rbins # bins in radius
VSF = V.void_vsf # void size function
parameters = [grid, MAS, '%s'%ptypes, threshold, '%s'%Radii]
# save the results to file
f = h5py.File(fout, 'w')
f.create_dataset('parameters', data=parameters)
f.create_dataset('pos', data=void_pos)
f.create_dataset('radius', data=void_radius)
f.create_dataset('VSF_Rbins', data=VSF_R)
f.create_dataset('VSF', data=VSF)
f.close()
def geometry(snapshot_fname, plane, x_min, x_max, y_min, y_max, z_min, z_max):
# read snapshot head and obtain BoxSize
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize / 1e3 #Mpc/h
plane_dict = {'XY': [0, 1], 'XZ': [0, 2], 'YZ': [1, 2]}
# check that the plane is square
if plane == 'XY':
length1 = x_max - x_min
length2 = y_max - y_min
depth = z_max - z_min
offset1 = x_min
offset2 = y_min
elif plane == 'XZ':
length1 = x_max - x_min
length2 = z_max - z_min
depth = y_max - y_min
offset1 = x_min
offset2 = z_min
else:
length1 = y_max - y_min
length2 = z_max - z_min
depth = x_max - x_min
offset1 = y_min
offset2 = z_min
if length1 != length2:
print 'Plane has to be a square!!!'
sys.exit()
BoxSize_slice = length1
return length1, offset1, length2, offset2, depth, BoxSize_slice
def compute_vf(snapshot, ptypes, grid, axis, MAS, fout):
if not (os.path.exists(snapshot + '.0')): return 0
# read header
header = readgadget.header(snapshot)
BoxSize = header.boxsize / 1e3 #Mpc/h
Nall = header.nall #Total number of particles
Masses = header.massarr * 1e10 #Masses of the particles in Msun/
redshift = header.redshift #redshift of the snapshot
# read positions and velocities
pos = readgadget.read_block(snapshot, "POS ", ptypes) / 1e3 #Mpc/h
vel = readgadget.read_block(snapshot, "VEL ", ptypes) #km/s
# compute density field
df = np.zeros((grid, grid, grid), dtype=np.float32)
MASL.MA(pos, df, BoxSize, MAS)
df[np.where(df == 0)] = 1e-7 # to avoid dividing by 0
# compute the velocity field
vf = np.zeros((grid, grid, grid), dtype=np.float32)
MASL.MA(pos, vf, BoxSize, MAS, W=vel[:, axis])
vf = vf / df
# save results to file
np.save(fout, df)
def measure_Overdensity(snapshot):
''' Measure delta from a snapshot using pylians3 mass-assignment scheme
'''
print("Reading snapshot file: %s \n" % (snapshot, ))
try:
# read header
header = readgadget.header(snapshot)
Boxsize = header.boxsize #/1e3 #Mpc/h. For Gadget2 snapshots uncomment /1e3
Nall = header.nall #Total number of particles
Masses = header.massarr * 1e10 #Masses of the particles in Msun/h format:[1](CDM), [2](neutrinos) or [1,2](CDM+neutrinos)
ptype = [Nall.nonzero()[0][0]
] #[1](CDM), [2](neutrinos) or [1,2](CDM+neutrinos)
except OSError:
print("Error: Overdensity File Not Found.\t")
exit()
print(
'Checking snapshot header data, they should agree.\t (right) initializeGlobals, (left) input parameters.\t'
)
print('Boxsize: %s should be equal to %s \t' % (BoxSize, Boxsize))
print('Particle type: %i should be equal to %i \t' % (ptypes[0], ptype[0]))
rho = MASL.density_field_gadget(snapshot, ptypes, gridSize, MAS, do_RSD,
axis)
delta = rho / np.mean(rho, dtype=np.float64)
delta -= 1.0 #overdensity
return delta
def find_pdf(snapshot, grid, MAS, do_RSD, axis, threads, ptype, fpdf,
smoothing, Filter):
if os.path.exists(fpdf): return 0
# read header
head = readgadget.header(snapshot)
BoxSize = head.boxsize / 1e3 #Mpc/h
Nall = head.nall #Total number of particles
Masses = head.massarr * 1e10 #Masses of the particles in Msun/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0 * np.sqrt(Omega_m *
(1.0 + redshift)**3 + Omega_l) #km/s/(Mpc/h)
h = head.hubble
# read snapshot
pos = readgadget.read_block(snapshot, "POS ", ptype) / 1e3 #Mpc/h
# move particles to redshift-space
if do_RSD:
vel = readgadget.read_block(snapshot, "VEL ", ptype) #km/s
RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis)
# calculate the overdensity field
delta = np.zeros((grid, grid, grid), dtype=np.float32)
if len(ptype) > 1: #for multiple particles read masses
mass = np.zeros(pos.shape[0], dtype=np.float32)
offset = 0
for j in ptype:
mass[offset:offset + Nall[j]] = Masses[j]
offset += Nall[j]
MASL.MA(pos, delta, BoxSize, MAS, W=mass)
else:
MASL.MA(pos, delta, BoxSize, MAS)
delta /= np.mean(delta, dtype=np.float64)
#delta -= 1.0
# define the array containing the variance
var = np.zeros(smoothing.shape[0], dtype=np.float64)
var_log = np.zeros(smoothing.shape[0], dtype=np.float64)
# do a loop over the different smoothing scales
for i, smooth_scale in enumerate(smoothing):
# smooth the overdensity field
W_k = SL.FT_filter(BoxSize, smooth_scale, grid, Filter, threads)
delta_smoothed = SL.field_smoothing(delta, W_k, threads)
# compute the variance of the field
var[i] = np.var(delta_smoothed)
indexes = np.where(delta_smoothed > 0.0)
var_log[i] = np.var(np.log10(delta_smoothed[indexes]))
# save results to file
np.savetxt(fpdf, np.transpose([smoothing, var, var_log]), delimiter='\t')
def Pk_comp(snapshot_fname,ptype,dims,do_RSD,axis,cpus,folder_out):
# read relevant paramaters on the header
print 'Computing power spectrum...'
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize/1e3 #Mpc/h
Masses = head.massarr*1e10 #Msun/h
Nall = head.nall; Ntotal = np.sum(Nall,dtype=np.int64)
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0*np.sqrt(Omega_m*(1.0+redshift)**3+Omega_l) #km/s/(Mpc/h)
z = '%.3f'%redshift
# find output file name
fout = folder_out+'/Pk_' + name_dict[str(ptype)]
if do_RSD: fout += ('_RS_axis=' + str(axis) + '_z=' + z + '.dat')
else: fout += ('_z=' + z + '.dat')
# read the positions of the particles
pos = readgadget.read_block(snapshot_fname,"POS ",[ptype])/1e3 #Mpc/h
print '%.3f < X [Mpc/h] < %.3f'%(np.min(pos[:,0]),np.max(pos[:,0]))
print '%.3f < Y [Mpc/h] < %.3f'%(np.min(pos[:,1]),np.max(pos[:,1]))
print '%.3f < Z [Mpc/h] < %.3f\n'%(np.min(pos[:,2]),np.max(pos[:,2]))
# read the velocities of the particles
if do_RSD:
print 'moving particles to redshift-space...'
vel = readgadget.read_block(snapshot_fname,"VEL ",[ptype]) #km/s
RSL.pos_redshift_space(pos,vel,BoxSize,Hubble,redshift,axis)
del vel; print 'done'
# define delta array
delta = np.zeros((dims,dims,dims),dtype=np.float32)
# when dealing with all particles take into account their different masses
if ptype==-1:
if Nall[0]==0: #if not hydro
M = np.zeros(Ntotal,dtype=np.float32) #define the mass array
offset = 0
for ptype in [0,1,2,3,4,5]:
M[offset:offset+Nall[ptype]] = Masses[ptype]
offset += Nall[ptype]
else:
M = readgadget.read_block(snapshot_fname,"MASS",ptype=[-1])*1e10
mean = np.sum(M,dtype=np.float64)/dims**3
MASL.MA(pos,delta,BoxSize,'CIC',M); del pos,M
else:
mean = len(pos)*1.0/dims**3
MASL.MA(pos,delta,BoxSize,'CIC'); del pos
# compute the P(k) and save results to file
delta /= mean; delta -= 1.0
Pk = PKL.Pk(delta,BoxSize,axis=axis,MAS='CIC',threads=cpus); del delta
np.savetxt(fout,np.transpose([Pk.k3D, Pk.Pk[:,0], Pk.Pk[:,1], Pk.Pk[:,2],
Pk.Nmodes3D]))
def compute_Pk(snapshot, grid, MAS, threads, ptype, root_out):
# read header
if not(os.path.exists(snapshot)): return 0
head = readgadget.header(snapshot)
BoxSize = head.boxsize/1e3 #Mpc/h
Nall = head.nall #Total number of particles
Masses = head.massarr*1e10 #Masses of the particles in Msun/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0*np.sqrt(Omega_m*(1.0+redshift)**3+Omega_l)#km/s/(Mpc/h)
h = head.hubble
Ntot = np.sum(Nall[ptype], dtype=np.int64)
# get the name of the output file
fout = '%s/Pk_%s_z=%.2f.txt'%(root_out, Pk_suffix(ptype), redshift)
if os.path.exists(fout): return 0
# define the arrays containing the number positions and masses of the particles
pos = np.zeros((Ntot,3), dtype=np.float32)
mass = np.zeros(Ntot, dtype=np.float32)
# read data for the different particle types
f = h5py.File(snapshot, 'r'); offset = 0
for pt in ptype:
# sometimes there are not black-holes or stars...
if 'PartType%d'%pt not in f.keys(): continue
# read positions
pos_pt = f['PartType%d/Coordinates'%pt][:]/1e3 #Mpc/h
if pos_pt.dtype==np.float64: pos_pt = pos_pt.astype(np.float32)
# read masses
if 'PartType%d/Masses'%pt in f:
mass_pt = f['PartType%d/Masses'%pt][:]*1e10 #Msun/h
else:
mass_pt = np.ones(pos_pt.shape[0], dtype=np.float32)*Masses[1] #Msun/h
# fill pos and mass arrays
length = len(pos_pt)
pos[offset:offset+length] = pos_pt
mass[offset:offset+length] = mass_pt
offset += length
f.close()
if offset!=Ntot: raise Exception('Not all particles counted')
# calculate density field
delta = np.zeros((grid,grid,grid), dtype=np.float32)
MASL.MA(pos, delta, BoxSize, MAS, W=mass)
delta /= np.mean(delta, dtype=np.float64); delta -= 1.0
# compute Pk and save results to file
axis = 0
Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads)
np.savetxt(fout, np.transpose([Pk.k3D, Pk.Pk[:,0]]), delimiter='\t')
def compute_Pk_ratio(root, sim, i, snapnum, root_out):
# find the number of N-body counterpart
#if i in map(str,np.arange(1522,1566)): j = 1505
#elif i in ['1505_0', '1505_1', '1505_2', '1505_3', '1505_4']: j = 1505
#elif i in ['0_test', '0_clean0', '0_clean1']: j = 0
#else: j = i
#if i in ['1505_0', '1505_1', '1505_2', '1505_3', '1505_4', '1505_5', '1505_6',
# '1505_7', '1505_8', '1505_9', '1505_10', '1505_11', '1505_12', '1505_13',
# '1505_14', '1505_15', '1505_16', '1505_17', '1505_18', '1505_19',
# '1505_20', '1505_21', '1505_22', '1505_23', '1505_24', '1505_25',
# '1505_26'] and sim=='IllustrisTNG':
# sim2='SIMBA'
#else: sim2=sim
# get the names of the snapshots
#snapshot1 = '%s/Sims/%s/%s/snap_%03d.hdf5'%(root,sim,i,snapnum)
#snapshot2 = '%s/Sims/%s_DM/%s/snap_%03d.hdf5'%(root,sim2,j,snapnum)
snapshot1 = '%s/Sims/%s/%s/snap_%03d.hdf5'%(root,sim,i,snapnum)
snapshot2 = '%s/Sims/%s_DM/%s/snap_%03d.hdf5'%(root,sim,i,snapnum)
if not(os.path.exists(snapshot1)) or not(os.path.exists(snapshot2)): return 0
# read the redshifts of the snapshots
redshift1 = (readgadget.header(snapshot1)).redshift
redshift2 = (readgadget.header(snapshot2)).redshift
# get the name of the output file
fout = '%s/Pk_ratio_m_z=%.2f.txt'%(root_out, redshift2)
if os.path.exists(fout): return 0
# get the name of the power spectra
f_hydro = '%s/Results/Pk/%s/%s/Pk_m_z=%.2f.txt'%(root,sim,i,redshift1)
f_nbody = '%s/Results/Pk/%s_DM/%s/Pk_m_z=%.2f.txt'%(root,sim,i,redshift2)
#f_nbody = '%s/Results/Pk/%s_DM/%s/Pk_m_z=%.2f.txt'%(root,sim,j,redshift2)
if not(os.path.exists(f_hydro)) or not(os.path.exists(f_nbody)): return 0
# read power spectra and save results to file
k1, Pk_hydro = np.loadtxt(f_hydro, unpack=True)
k2, Pk_nbody = np.loadtxt(f_nbody, unpack=True)
if np.any(k1!=k2): raise Exception('k-values differ!')
np.savetxt(fout, np.transpose([k1,Pk_hydro/Pk_nbody]))
def baryon_fraction_SO(RMmin, RMmax, bins, f_SO, snapshot, root_out):
# check if SO file exists
if not(os.path.exists(f_SO)): return 0
# read header and get masses of CDM particles
head = readgadget.header(snapshot)
BoxSize = head.boxsize/1e3 #Mpc/h
Om = head.omega_m
redshift = head.redshift
# get the name of the output file
fout1 = '%s/bf_SO_%.2e_%.2e_%d_z=%.2f.txt'%(root_out, RMmin, RMmax, bins, redshift)
fout2 = '%s/gf_SO_%.2e_%.2e_%d_z=%.2f.txt'%(root_out, RMmin, RMmax, bins, redshift)
if os.path.exists(fout1) and os.path.exists(fout2): return 0
# read halo masses
data = np.loadtxt(f_SO, unpack=False)
halo_mass = data[:,0]
Mg = data[:,5]
Mc = data[:,6]
Ms = data[:,7]
Mbh = data[:,8]
Nc = data[:,11]
# take only halos with more than 50 CDM particles
indexes = np.where(Nc>50)[0]
halo_mass = halo_mass[indexes]
Mg = Mg[indexes]
Mc = Mc[indexes]
Ms = Ms[indexes]
Mbh = Mbh[indexes]
# define the bins with the number of CDM particles and the intervals mean
RM_bins = np.logspace(np.log10(RMmin), np.log10(RMmax), bins+1)
RM_mean = 10**(0.5*(np.log10(RM_bins[1:]) + np.log10(RM_bins[:-1])))
# compute baryon fraction in units of cosmic fraction
fraction1 = ((Mg + Ms + Mbh)/halo_mass) / (0.049/Om)
fraction2 = (Mg/halo_mass) / (0.049/Om)
# take bins in halo mass / Omega_m. Compute average baryon fraction
mean_fraction1 = np.histogram(halo_mass/Om, RM_bins, weights=fraction1)[0]
mean_fraction2 = np.histogram(halo_mass/Om, RM_bins, weights=fraction2)[0]
Number = np.histogram(halo_mass/Om, RM_bins)[0]
Number[np.where(Number==0)] = 1.0
mean_fraction1 = mean_fraction1/Number
mean_fraction2 = mean_fraction2/Number
# save results to file
np.savetxt(fout1, np.transpose([RM_mean, mean_fraction1]))
np.savetxt(fout2, np.transpose([RM_mean, mean_fraction2]))
def find_Bk(snapshot, snapnum, Ngrid, Nmax, Ncut, step, do_RSD, axis, ptype,
fbk):
# read header
head = readgadget.header(snapshot)
BoxSize = head.boxsize / 1e3 #Mpc/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0 * np.sqrt(Omega_m *
(1.0 + redshift)**3 + Omega_l) #km/s/(Mpc/h)
h = head.hubble
# read the snapshot
pos = readgadget.read_block(snapshot, "POS ", ptype) / 1e3 #Mpc/h
# move positions to redshift-space
if do_RSD:
vel = readgadget.read_block(snapshot, "VEL ", ptype) #km/s
RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis)
# calculate bispectrum
b123out = pySpec.Bk_periodic(pos.T,
Lbox=BoxSize,
Ngrid=Ngrid,
step=step,
Ncut=Ncut,
Nmax=Nmax,
fft='pyfftw',
nthreads=1,
silent=False)
i_k = b123out['i_k1']
j_k = b123out['i_k2']
l_k = b123out['i_k3']
p0k1 = b123out['p0k1']
p0k2 = b123out['p0k2']
p0k3 = b123out['p0k3']
b123 = b123out['b123']
b_sn = b123out['b123_sn']
q123 = b123out['q123']
cnts = b123out['counts']
hdr = ('matter bispectrum; k_f = 2pi/%.1f, Nhalo=%i' %
(BoxSize, pos.shape[0]))
np.savetxt(
fbk,
np.array([i_k, j_k, l_k, p0k1, p0k2, p0k3, b123, q123, b_sn, cnts]).T,
fmt='%i %i %i %.5e %.5e %.5e %.5e %.5e %.5e %.5e',
delimiter='\t',
header=hdr)
def find_pdf(snapshot, grid, MAS, do_RSD, axis, threads, ptype, fpdf,
smoothing, Filter):
if os.path.exists(fpdf): return 0
# read header
head = readgadget.header(snapshot)
BoxSize = head.boxsize / 1e3 #Mpc/h
Nall = head.nall #Total number of particles
Masses = head.massarr * 1e10 #Masses of the particles in Msun/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0 * np.sqrt(Omega_m *
(1.0 + redshift)**3 + Omega_l) #km/s/(Mpc/h)
h = head.hubble
# read snapshot
pos = readgadget.read_block(snapshot, "POS ", ptype) / 1e3 #Mpc/h
# move particles to redshift-space
if do_RSD:
vel = readgadget.read_block(snapshot, "VEL ", ptype) #km/s
RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis)
# calculate the overdensity field
delta = np.zeros((grid, grid, grid), dtype=np.float32)
if len(ptype) > 1: #for multiple particles read masses
mass = np.zeros(pos.shape[0], dtype=np.float32)
offset = 0
for j in ptype:
mass[offset:offset + Nall[j]] = Masses[j]
offset += Nall[j]
MASL.MA(pos, delta, BoxSize, MAS, W=mass)
else:
MASL.MA(pos, delta, BoxSize, MAS)
delta /= np.mean(delta, dtype=np.float64)
#delta -= 1.0
# smooth the overdensity field
W_k = SL.FT_filter(BoxSize, smoothing, grid, Filter, threads)
delta_smoothed = SL.field_smoothing(delta, W_k, threads)
bins = np.logspace(-2, 2, 100)
pdf, mean = np.histogram(delta_smoothed, bins=bins)
mean = 0.5 * (mean[1:] + mean[:-1])
pdf = pdf * 1.0 / grid**3
# save results to file
np.savetxt(fpdf, np.transpose([mean, pdf]), delimiter='\t')
def find_CF(snapshot, snapnum, grid, MAS, do_RSD, axis, threads, ptype, fcf,
save_multipoles):
if os.path.exists(fcf): return 0
# read header
head = readgadget.header(snapshot)
BoxSize = head.boxsize / 1e3 #Mpc/h
Nall = head.nall #Total number of particles
Masses = head.massarr * 1e10 #Masses of the particles in Msun/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0 * np.sqrt(Omega_m *
(1.0 + redshift)**3 + Omega_l) #km/s/(Mpc/h)
h = head.hubble
# read snapshot
pos = readgadget.read_block(snapshot, "POS ", ptype) / 1e3 #Mpc/h
# move particles to redshift-space
if do_RSD:
vel = readgadget.read_block(snapshot, "VEL ", ptype) #km/s
RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis)
# calculate CF
delta = np.zeros((grid, grid, grid), dtype=np.float32)
if len(ptype) > 1: #for multiple particles read masses
mass = np.zeros(pos.shape[0], dtype=np.float32)
offset = 0
for j in ptype:
mass[offset:offset + Nall[j]] = Masses[j]
offset += Nall[j]
MASL.MA(pos, delta, BoxSize, MAS, W=mass)
else:
MASL.MA(pos, delta, BoxSize, MAS)
delta /= np.mean(delta, dtype=np.float64)
delta -= 1.0
CF = PKL.Xi(delta, BoxSize, MAS, axis, threads)
# save results to file
if save_multipoles:
np.savetxt(fcf,
np.transpose(
[CF.r3D, CF.xi[:, 0], CF.xi[:, 1], CF.xi[:, 2]]),
delimiter='\t')
else:
np.savetxt(fcf, np.transpose([CF.r3D, CF.xi[:, 0]]), delimiter='\t')
def baryon_fraction_FoF(RMmin, RMmax, bins, f_subfind, snapshot, root_out):
# check if subfind file exists
if not(os.path.exists(f_subfind)): return 0
# read header and get masses of CDM particles
head = readgadget.header(snapshot)
BoxSize = head.boxsize/1e3 #Mpc/h
Masses = head.massarr*1e10 #Masses of the particles in Msun/h
Nall = head.nall #Total number of particles
Om = head.omega_m
redshift = head.redshift
Mc = (Om - 0.049)*BoxSize**3*rho_crit/Nall[1] #mass of a CDM particle
# get the name of the output file
fout = '%s/bf_%.2e_%.2e_%d_z=%.2f.txt'%(root_out,RMmin, RMmax, bins, redshift)
if os.path.exists(fout): return 0
# read halo masses
f = h5py.File(f_subfind, 'r')
halo_mass = f['Group/GroupMass'][:]*1e10
halo_mass_type = f['Group/GroupMassType'][:]*1e10
halo_part_type = f['Group/GroupLenType'][:] #number of particles in each halo
f.close()
# take only halos with more than 50 CDM particles
indexes = np.where(halo_part_type[:,1]>50)[0]
halo_mass = halo_mass[indexes]
halo_mass_type = halo_mass_type[indexes]
# define the bins with the number of CDM particles and the intervals mean
RM_bins = np.logspace(np.log10(RMmin), np.log10(RMmax), bins+1)
RM_mean = 10**(0.5*(np.log10(RM_bins[1:]) + np.log10(RM_bins[:-1])))
# compute baryon fraction in units of cosmic fraction
fraction = ((halo_mass_type[:,0] + halo_mass_type[:,4] + halo_mass_type[:,5])/halo_mass) / (0.049/Om)
# take bins in halo mass / Omega_m. Compute average baryon fraction
mean_fraction = np.histogram(halo_mass/Om, RM_bins, weights=fraction)[0]
Number = np.histogram(halo_mass/Om, RM_bins)[0]
Number[np.where(Number==0)] = 1.0
mean_fraction = mean_fraction/Number
# save results to file
np.savetxt(fout, np.transpose([RM_mean, mean_fraction]))
def find_Pk(folder, snapdir, snapnum, grid, MAS, do_RSD, axis, threads,
fixed_Mmin, Mmin, Nhalos, fpk, save_multipoles):
if os.path.exists(fpk): return 0
# read header
head = readgadget.header(snapdir)
BoxSize = head.boxsize/1e3 #Mpc/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0*np.sqrt(Omega_m*(1.0+redshift)**3+Omega_l)#km/s/(Mpc/h)
h = head.hubble
# read halo catalogue
FoF = readfof.FoF_catalog(folder, snapnum, long_ids=False,
swap=False, SFR=False, read_IDs=False)
pos_h = FoF.GroupPos/1e3 #Mpc/h
mass = FoF.GroupMass*1e10 #Msun/h
vel_h = FoF.GroupVel*(1.0+redshift) #km/s
if fixed_Mmin:
indexes = np.where(mass>Mmin)[0]
pos_h = pos_h[indexes]; vel_h = vel_h[indexes]; del indexes
else:
indexes = np.argsort(mass)[-Nhalos:] #take the Nhalos most massive halos
pos_h = pos_h[indexes]; vel_h = vel_h[indexes]; del indexes
# move halos to redshift-space
if do_RSD: RSL.pos_redshift_space(pos_h, vel_h, BoxSize, Hubble, redshift, axis)
# calculate Pk
delta = np.zeros((grid,grid,grid), dtype=np.float32)
MASL.MA(pos_h, delta, BoxSize, MAS)
delta /= np.mean(delta, dtype=np.float64); delta -= 1.0
Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads)
# save results to file
hdr = ('Nhalos=%i BoxSize=%.3f'%(pos_h.shape[0],BoxSize))
if save_multipoles:
np.savetxt(fpk, np.transpose([Pk.k3D, Pk.Pk[:,0], Pk.Pk[:,1], Pk.Pk[:,2]]),
delimiter='\t', header=hdr)
else:
np.savetxt(fpk, np.transpose([Pk.k3D, Pk.Pk[:,0]]),
delimiter='\t', header=hdr)
def density_field_gadget(snapshot_fname, ptypes, dims, MAS='CIC',
do_RSD=False, axis=0, verbose=True):
start = time.time()
if verbose: print('\nComputing density field of particles',ptypes)
# declare the array hosting the density field
density = np.zeros((dims, dims, dims), dtype=np.float32)
# read relevant paramaters on the snapshot
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize/1e3 #Mpc/h
Masses = head.massarr*1e10 #Msun/h
Nall = head.nall; Ntotal = np.sum(Nall,dtype=np.int64)
filenum = head.filenum
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
fformat = head.format
def compute_Pk_ICs(snapshot, grid, MAS, threads, ptype, root_out):
if not(os.path.exists(snapshot)) and not(os.path.exists(snapshot+'.0')): return 0
# read header
head = readgadget.header(snapshot)
BoxSize = head.boxsize/1e3 #Mpc/h
redshift = head.redshift
# get the name of the file
fout = '%s/Pk_%s_z=%.2f.txt'%(root_out, Pk_suffix(ptype), redshift)
if os.path.exists(fout): return 0
# compute overdensity field
do_RSD, axis = False, 0
delta = MASL.density_field_gadget(snapshot, ptype, grid, MAS, do_RSD, axis)
delta /= np.mean(delta, dtype=np.float64); delta -= 1.0
# compute Pk and save results to file
Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads)
np.savetxt(fout, np.transpose([Pk.k3D, Pk.Pk[:,0]]), delimiter='\t')
def halo_mass_function(RMmin, RMmax, bins, f_subfind, snapshot, root_out):
# check if subfind file exists
if not(os.path.exists(f_subfind)): return 0
# read header and get masses of CDM particles
head = readgadget.header(snapshot)
BoxSize = head.boxsize/1e3 #Mpc/h
Masses = head.massarr*1e10 #Masses of the particles in Msun/h
Nall = head.nall #Total number of particles
Om = head.omega_m
redshift = head.redshift
# get the name of the output file
fout = '%s/mass_function_%.2e_%.2e_%d_z=%.2f.txt'%(root_out,RMmin,RMmax,bins,redshift)
if os.path.exists(fout): return 0
# read halo masses
f = h5py.File(f_subfind, 'r')
halo_mass = f['Group/GroupMass'][:]*1e10 #Msun/h
halo_part_type = f['Group/GroupLenType'][:] #number of particles in each halo
f.close()
# take only halos with more than 50 CDM particles
indexes = np.where(halo_part_type[:,1]>50)[0]
halo_mass = halo_mass[indexes]
# define the arrays with the reduced mass (mass/Omega_m) bins, mean and width
RM_bins = np.logspace(np.log10(RMmin), np.log10(RMmax), bins+1)
RM_mean = 10**(0.5*(np.log10(RM_bins[1:]) + np.log10(RM_bins[:-1])))
dRM = RM_bins[1:] - RM_bins[:-1]
# compute halo mass function and save results to file
HMF = np.histogram(halo_mass/Om, RM_bins)[0]
HMF = HMF/(BoxSize**3*dRM*Om)
np.savetxt(fout, np.transpose([RM_mean*Om, RM_mean, HMF]))
def read_header(snap):
snapshot_fname = '/cosma6/data/dp004/dc-smit4/Daemmerung/Planck2013-Npart_2048_Box_3000-Fiducial/run1/snapdir_{0:03d}/Planck2013-L3000-N2048-Fiducial_{0:03d}.0'.format(
snap)
return readgadget.header(snapshot_fname)
if ptypes==[-1]: ptypes = [0, 1, 2, 3, 4, 5] if len(ptypes)==1: single_component=True else: single_component=False # do a loop over all files num = 0.0 for i in range(filenum): # find the name of the sub-snapshot if filenum==1: snapshot = snapshot_fname else: snapshot = snapshot_fname+'.%d'%i if fformat=='hdf5': snapshot = snapshot+'.hdf5' # find the local particles in the sub-snapshot head = readgadget.header(snapshot) npart = head.npart # do a loop over all particle types for ptype in ptypes: if npart[ptype]==0: continue # read positions in Mpc/h pos = readgadget.read_field(snapshot, "POS ", ptype)/1e3 #pos = readsnap.read_block(snapshot,"POS ",parttype=ptype)/1e3 # read velocities in km/s and move particles to redshift-space if do_RSD: vel = readgadget.read_field(snapshot, "VEL ", ptype) #vel = readsnap.read_block(snapshot,"VEL ",parttype=ptype)
import numpy as np import readgadget tng = '/home/jovyan/Simulations/IllustrisTNG/1P_0/ICs/ics' smb = '/home/jovyan/Simulations/SIMBA/1P_0/ICs/ics' header_tng = readgadget.header(tng) header_smb = readgadget.header(smb) h_tng = header_tng.hubble h_smb = header_smb.hubble print(h_tng) print(h_smb)
def find_Bk(folder, snapdir, snapnum, axis, Ngrid, step, Ncut, Nmax, do_RSD,
fixed_Mmin, Mmin, Nhalos):
# read header
head = readgadget.header(snapdir)
BoxSize = head.boxsize / 1e3 #Mpc/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0 * np.sqrt(Omega_m *
(1.0 + redshift)**3 + Omega_l) #km/s/(Mpc/h)
h = head.hubble
# read halo catalogue
FoF = readfof.FoF_catalog(folder,
snapnum,
long_ids=False,
swap=False,
SFR=False,
read_IDs=False)
pos_h = FoF.GroupPos / 1e3 #Mpc/h
mass = FoF.GroupMass * 1e10 #Msun/h
vel_h = FoF.GroupVel * (1.0 + redshift) #km/s
if fixed_Mmin:
indexes = np.where(mass > Mmin)[0]
pos_h = pos_h[indexes]
vel_h = vel_h[indexes]
del indexes
else:
indexes = np.argsort(mass)[
-Nhalos:] #take the Nhalos most massive halos
pos_h = pos_h[indexes]
vel_h = vel_h[indexes]
del indexes
# move halos to redshift-space
if do_RSD:
RSL.pos_redshift_space(pos_h, vel_h, BoxSize, Hubble, redshift, axis)
# calculate bispectrum
b123out = pySpec.Bk_periodic(pos_h.T,
Lbox=BoxSize,
Ngrid=Ngrid,
step=step,
Ncut=Ncut,
Nmax=Nmax,
fft='pyfftw',
nthreads=1,
silent=False)
i_k = b123out['i_k1']
j_k = b123out['i_k2']
l_k = b123out['i_k3']
p0k1 = b123out['p0k1']
p0k2 = b123out['p0k2']
p0k3 = b123out['p0k3']
b123 = b123out['b123']
b_sn = b123out['b123_sn']
q123 = b123out['q123']
cnts = b123out['counts']
hdr = ('halo bispectrum; k_f = 2pi/%.1f, Nhalo=%i' %
(BoxSize, pos_h.shape[0]))
np.savetxt(
fbk,
np.array([i_k, j_k, l_k, p0k1, p0k2, p0k3, b123, q123, b_sn, cnts]).T,
fmt='%i %i %i %.5e %.5e %.5e %.5e %.5e %.5e %.5e',
delimiter='\t',
header=hdr)
def density_field_2D(snapshot_fname, x_min, x_max, y_min, y_max, z_min, z_max,
dims, ptypes, plane, MAS, save_density_field):
plane_dict = {'XY': [0, 1], 'XZ': [0, 2], 'YZ': [1, 2]}
# read snapshot head and obtain BoxSize, filenum...
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize / 1e3 #Mpc/h
Nall = head.nall
Masses = head.massarr * 1e10 #Msun/h
filenum = head.filenum
redshift = head.redshift
# find the geometric values of the density field square
len_x, off_x, len_y, off_y, depth, BoxSize_slice = \
geometry(snapshot_fname, plane, x_min, x_max, y_min, y_max,
z_min, z_max)
# compute the mean density in the box
if len(ptypes) == 1 and Masses[ptypes[0]] != 0.0:
single_specie = True
else:
single_specie = False
# define the density array
overdensity = np.zeros((dims, dims), dtype=np.float32)
# do a loop over all subfiles in the snapshot
total_mass, mass_slice = 0.0, 0.0
renormalize_2D = False
for i in xrange(filenum):
# find the name of the subfile
snap = snapshot_fname + '.%d' % i
# in the last snapshot we renormalize the field
if i == filenum - 1: renormalize_2D = True
# do a loop over
for ptype in ptypes:
# read the positions of the particles in Mpc/h
pos = readgadget.read_field(snap, "POS ", ptype) / 1e3
if single_specie: total_mass += len(pos)
# keep only with the particles in the slice
indexes = np.where((pos[:, 0] > x_min) & (pos[:, 0] < x_max)
& (pos[:, 1] > y_min) & (pos[:, 1] < y_max)
& (pos[:, 2] > z_min) & (pos[:, 2] < z_max))
pos = pos[indexes]
# renormalize positions
pos[:, 0] -= x_min
pos[:, 1] -= y_min
pos[:, 2] -= z_min
# project particle positions into a 2D plane
pos = pos[:, plane_dict[plane]]
# read the masses of the particles in Msun/h
if not (single_specie):
mass = readgadget.read_field(snap, "MASS", ptype) * 1e10
total_mass += np.sum(mass, dtype=np.float64)
mass = mass[indexes]
MASL.MA(pos,
overdensity,
BoxSize_slice,
MAS=MAS,
W=mass,
renormalize_2D=renormalize_2D)
else:
mass_slice += len(pos)
MASL.MA(pos,
overdensity,
BoxSize_slice,
MAS=MAS,
W=None,
renormalize_2D=renormalize_2D)
print 'Expected mass = %.7e' % mass_slice
print 'Computed mass = %.7e' % np.sum(overdensity, dtype=np.float64)
# compute mean density in the whole box
mass_density = total_mass * 1.0 / BoxSize**3 #(Msun/h)/(Mpc/h)^3 or #/(Mpc/h)^3
print 'mass density = %.5e' % mass_density
# compute the volume of each cell in the density field slice
V_cell = BoxSize_slice**2 * depth * 1.0 / dims**2 #(Mpc/h)^3
# compute the mean mass in each cell of the slice
mean_mass = mass_density * V_cell #Msun/h or #
# compute overdensities
overdensity /= mean_mass
print np.min(overdensity), '< rho/<rho> <', np.max(overdensity)
# in our convention overdensity(x,y), while for matplotlib is
# overdensity(y,x), so we need to transpose the field
overdensity = np.transpose(overdensity)
# save density field to file
f_df = density_field_name(snapshot_fname, x_min, x_max, y_min, y_max,
z_min, z_max, dims, ptypes, plane, MAS)
if save_density_field: np.save(f_df, overdensity)
return overdensity
def Pk_Gadget(snapshot_fname,
dims,
particle_type,
do_RSD,
axis,
cpus,
folder_out=None):
# find folder to place output files. Default is current directory
if folder_out is None: folder_out = os.getcwd()
# for either one single species or all species use this routine
if len(particle_type) == 1:
Pk_comp(snapshot_fname, particle_type[0], dims, do_RSD, axis, cpus,
folder_out)
return None
# read snapshot head and obtain BoxSize, Omega_m and Omega_L
print('\nREADING SNAPSHOTS PROPERTIES')
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize / 1e3 #Mpc/h
Nall = head.nall
Masses = head.massarr * 1e10 #Msun/h
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
Hubble = 100.0 * np.sqrt(Omega_m *
(1.0 + redshift)**3 + Omega_l) #km/s/(Mpc/h)
h = head.hubble
z = '%.3f' % redshift
dims3 = dims**3
# compute the values of Omega_cdm, Omega_nu, Omega_gas and Omega_s
Omega_c = Masses[1] * Nall[1] / BoxSize**3 / rho_crit
Omega_n = Masses[2] * Nall[2] / BoxSize**3 / rho_crit
Omega_g, Omega_s = 0.0, 0.0
if Nall[0] > 0:
if Masses[0] > 0:
Omega_g = Masses[0] * Nall[0] / BoxSize**3 / rho_crit
Omega_s = Masses[4] * Nall[4] / BoxSize**3 / rho_crit
else:
# mass in Msun/h
mass = readgadget.read_block(snapshot_fname, "MASS",
ptype=[0]) * 1e10
Omega_g = np.sum(mass, dtype=np.float64) / BoxSize**3 / rho_crit
mass = readgadget.read_block(snapshot_fname, "MASS",
ptype=[4]) * 1e10
Omega_s = np.sum(mass, dtype=np.float64) / BoxSize**3 / rho_crit
del mass
# some verbose
print('Omega_gas = ', Omega_g)
print('Omega_cdm = ', Omega_c)
print('Omega_nu = ', Omega_n)
print('Omega_star = ', Omega_s)
print('Omega_m = ', Omega_g + Omega_c + Omega_n + Omega_s)
print('Omega_m snap = ', Omega_m)
# dictionary giving the value of Omega for each component
Omega_dict = {0: Omega_g, 1: Omega_c, 2: Omega_n, 4: Omega_s}
#####################################################################
# define the array containing the deltas
delta = [[], [], [],
[]] #array containing the gas, CDM, NU and stars deltas
# dictionary among particle type and the index in the delta and Pk arrays
# delta of stars (ptype=4) is delta[3] not delta[4]
index_dict = {0: 0, 1: 1, 2: 2, 4: 3}
# define suffix here
if do_RSD: suffix = '_RS_axis=' + str(axis) + '_z=' + z + '.dat'
else: suffix = '_z=' + z + '.dat'
#####################################################################
# do a loop over all particle types and compute the deltas
for ptype in particle_type:
# read particle positions in #Mpc/h
pos = readgadget.read_block(snapshot_fname, "POS ", [ptype]) / 1e3
# move particle positions to redshift-space
if do_RSD:
vel = readgadget.read_block(snapshot_fname, "VEL ", [ptype]) #km/s
RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis)
del vel
# find the index of the particle type in the delta array
index = index_dict[ptype]
# compute mean number of particles per grid cell
mean_number = len(pos) * 1.0 / dims3
# compute the deltas
delta[index] = np.zeros((dims, dims, dims), dtype=np.float32)
MASL.MA(pos, delta[index], BoxSize, 'CIC')
del pos
delta[index] /= mean_number
delta[index] -= 1.0
#####################################################################
#####################################################################
# if there are two or more particles compute auto- and cross-power spectra
for i, ptype1 in enumerate(particle_type):
for ptype2 in particle_type[i + 1:]:
# find the indexes of the particle types
index1 = index_dict[ptype1]
index2 = index_dict[ptype2]
# choose the name of the output files
fout1 = '/Pk_' + name_dict[str(ptype1)] + suffix
fout2 = '/Pk_' + name_dict[str(ptype2)] + suffix
fout12 = '/Pk_' + name_dict[str(ptype1) + str(ptype2)] + suffix
fout1 = folder_out + fout1
fout2 = folder_out + fout2
fout12 = folder_out + fout12
# some verbose
print('\nComputing the auto- and cross-power spectra of types: '\
,ptype1,'-',ptype2)
print('saving results in:')
print(fout1, '\n', fout2, '\n', fout12)
# This routine computes the auto- and cross-power spectra
data = PKL.XPk([delta[index1], delta[index2]],
BoxSize,
axis=axis,
MAS=['CIC', 'CIC'],
threads=cpus)
k = data.k3D
Nmodes = data.Nmodes3D
# save power spectra results in the output files
np.savetxt(
fout12,
np.transpose([
k, data.XPk[:, 0, 0], data.XPk[:, 1, 0], data.XPk[:, 2, 0],
Nmodes
]))
np.savetxt(
fout1,
np.transpose([
k, data.Pk[:, 0, 0], data.Pk[:, 1, 0], data.Pk[:, 2, 0],
Nmodes
]))
np.savetxt(
fout2,
np.transpose([
k, data.Pk[:, 0, 1], data.Pk[:, 1, 1], data.Pk[:, 2, 1],
Nmodes
]))
#####################################################################
#####################################################################
# compute the power spectrum of the sum of all components
print('\ncomputing P(k) of all components')
# define delta of all components
delta_tot = np.zeros((dims, dims, dims), dtype=np.float32)
Omega_tot = 0.0
fout = folder_out + '/Pk_'
for ptype in particle_type:
index = index_dict[ptype]
delta_tot += (Omega_dict[ptype] * delta[index])
Omega_tot += Omega_dict[ptype]
fout += name_dict[str(ptype)] + '+'
delta_tot /= Omega_tot
del delta
fout = fout[:-1] #avoid '+' in the end
# compute power spectrum
data = PKL.Pk(delta_tot, BoxSize, axis=axis, MAS='CIC', threads=cpus)
del delta_tot
# write P(k) to output file
np.savetxt(
fout + suffix,
np.transpose([
data.k3D, data.Pk[:, 0], data.Pk[:, 1], data.Pk[:, 2],
data.Nmodes3D
]))
def density_field_2D(snapshot, x_min, x_max, y_min, y_max, z_min, z_max,
dims, ptypes, plane, MAS, save_density_field):
# find the geometric values of the density field square
dx, x, dy, y, depth, BoxSize_slice = \
geometry(snapshot, plane, x_min, x_max, y_min, y_max, z_min, z_max)
# find the name of the density field and read it if already exists
f_df = density_field_name(snapshot, x_min, x_max, y_min, y_max,
z_min, z_max, dims, ptypes, plane, MAS)
if os.path.exists(f_df):
print('\nDensity field already computed. Reading it from file...')
overdensity = np.load(f_df); return dx, x, dy, y, overdensity
# if not, compute it
print('\nComputing density field...')
plane_dict = {'XY':[0,1], 'XZ':[0,2], 'YZ':[1,2]}
# read snapshot head and obtain BoxSize, filenum...
head = readgadget.header(snapshot)
BoxSize = head.boxsize/1e3 #Mpc/h
Nall = head.nall
Masses = head.massarr*1e10 #Msun/h
filenum = head.filenum
redshift = head.redshift
# define the density array
overdensity = np.zeros((dims,dims), dtype=np.float32)
# do a loop over all subfiles in the snapshot
total_mass, mass_slice = 0.0, 0.0; renormalize_2D = False
for i in range(filenum):
# find the name of the subfile
snap1 = '%s.%d'%(snapshot,i)
snap2 = '%s.%d.hdf5'%(snapshot,i)
snap3 = '%s'%(snapshot)
if os.path.exists(snap1): snap = snap1
elif os.path.exists(snap2): snap = snap2
elif os.path.exists(snap3): snap = snap3
else: raise Exception('Problem with the snapshot name!')
# in the last subfile we renormalize the field
if i==filenum-1: renormalize_2D = True
# do a loop over all particle types
for ptype in ptypes:
# read the positions of the particles in Mpc/h
pos = readgadget.read_field(snap,"POS ",ptype)/1e3
# keep only with the particles in the slice
indexes = np.where((pos[:,0]>x_min) & (pos[:,0]<x_max) &
(pos[:,1]>y_min) & (pos[:,1]<y_max) &
(pos[:,2]>z_min) & (pos[:,2]<z_max) )
pos = pos[indexes]
# renormalize positions
pos[:,0] -= x_min; pos[:,1] -= y_min; pos[:,2] -= z_min
# project particle positions into a 2D plane
pos = pos[:,plane_dict[plane]]
# read the masses of the particles
mass = readgadget.read_field(snap,"MASS",ptype)*1e10
total_mass += np.sum(mass, dtype=np.float64)
mass = mass[indexes]; mass_slice += np.sum(mass)
# update 2D density field
MASL.MA(pos, overdensity, BoxSize_slice, MAS=MAS, W=mass,
renormalize_2D=renormalize_2D)
print('Expected mass = %.7e'%mass_slice)
print('Computed mass = %.7e'%np.sum(overdensity, dtype=np.float64))
# compute mean density in the whole box
mass_density = total_mass*1.0/BoxSize**3 #(Msun/h)/(Mpc/h)^3 or #/(Mpc/h)^3
print('mass density = %.5e'%mass_density)
# compute the volume and mean mass of each cell of the slice
V_cell = BoxSize_slice**2*depth*1.0/dims**2 #(Mpc/h)^3
mean_mass = mass_density*V_cell #Msun/h or #
# compute overdensities
overdensity /= mean_mass
print(np.min(overdensity),'< rho/<rho> <',np.max(overdensity))
# in our convention overdensity(x,y), while for matplotlib is
# overdensity(y,x), so we need to transpose the field
overdensity = np.transpose(overdensity)
# save density field to file
if save_density_field: np.save(f_df, overdensity)
return dx, x, dy, y, overdensity
def density_field_gadget(snapshot_fname, ptypes, dims, MAS='CIC',
do_RSD=False, axis=0, verbose=True):
start = time.time()
if verbose: print '\nComputing density field of particles',ptypes
# declare the array hosting the density field
density = np.zeros((dims, dims, dims), dtype=np.float32)
# read relevant paramaters on the snapshot
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize/1e3 #Mpc/h
Masses = head.massarr*1e10 #Msun/h
Nall = head.nall; Ntotal = np.sum(Nall,dtype=np.int64)
filenum = head.filenum
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
fformat = head.format
Hubble = head.Hubble
if ptypes==[-1]: ptypes = [0, 1, 2, 3, 4, 5]
if len(ptypes)==1: single_component=True
else: single_component=False
# do a loop over all files
num = 0.0
for i in xrange(filenum):
# find the name of the sub-snapshot
if filenum==1: snapshot = snapshot_fname
else: snapshot = snapshot_fname+'.%d'%i
if fformat=='hdf5': snapshot = snapshot+'.hdf5'
# find the local particles in the sub-snapshot
head = readgadget.header(snapshot)
npart = head.npart
# do a loop over all particle types
for ptype in ptypes:
if npart[ptype]==0: continue
# read positions in Mpc/h
pos = readgadget.read_field(snapshot, "POS ", ptype)/1e3
#pos = readsnap.read_block(snapshot,"POS ",parttype=ptype)/1e3
# read velocities in km/s and move particles to redshift-space
if do_RSD:
vel = readgadget.read_field(snapshot, "VEL ", ptype)
#vel = readsnap.read_block(snapshot,"VEL ",parttype=ptype)
RSL.pos_redshift_space(pos,vel,BoxSize,Hubble,redshift,axis)
del vel
# compute density field. If multicomponent, read/find masses
if Masses[ptype]!=0:
if single_component:
MASL.MA(pos, density, BoxSize, MAS)
num += pos.shape[0]
else:
mass = np.ones(npart[ptype], dtype=np.float32)*Masses[ptype]
MASL.MA(pos, density, BoxSize, MAS, W=mass)
num += np.sum(mass, dtype=np.float64)
else:
mass = readgadget.read_field(snapshot, "MASS", ptype)*1e10
#mass = readsnap.read_block(snapshot,"MASS",
# parttype=ptype)*1e10 #Msun/h
MASL.MA(pos, density, BoxSize, MAS, W=mass)
num += np.sum(mass, dtype=np.float64)
if verbose:
print '%.8e should be equal to\n%.8e'\
%(np.sum(density, dtype=np.float64), num)
print 'Time taken = %.2f seconds'%(time.time()-start)
return np.asarray(density)
def do_snap(snap):
#load shapshot
print('Loading snapshot', snap)
snapshot_fname = '/cosma6/data/dp004/dc-smit4/Daemmerung/Planck2013-Npart_2048_Box_3000-Fiducial/run1/snapdir_{0:03d}/Planck2013-L3000-N2048-Fiducial_{0:03d}'.format(
snap)
density_fname = '/cosma6/data/dp004/dc-boot5/Lightcone/Density/density_{0:03d}.npy'.format(
snap)
powerspec_path = '/cosma6/data/dp004/dc-boot5/Lightcone/Power_Spectrum/'
lightcone_path = "/cosma6/data/dp004/dc-boot5/Lightcone/Galaxy_FullSky/"
#calculate density delta
# declare the array hosting the density field
density = np.zeros((dims, dims, dims), dtype=np.float32)
# read relevant paramaters on the snapshot
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize / 1e3 #Mpc/h
Masses = head.massarr * 1e10 #Msun/h
Nall = head.nall
filenum = head.filenum
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
fformat = head.format
Hubble = head.Hubble
Ntotal = np.sum(Nall, dtype=np.int64)
grid = 2048
MAS = 'CIC'
axis = 0
do_RSD = True
BoxSize = 3000 #Mpc/h
ptype = 1 #dark matter
# do a loop over all files
num = 0.0
for i in range(filenum):
# find the name of the sub-snapshot
if filenum == 1: snapshot = snapshot_fname
else: snapshot = snapshot_fname + '.{0:d}'.format(i)
if fformat == 'hdf5': snapshot = snapshot + '.hdf5'
# find the local particles in the sub-snapshot
head = readgadget.header(snapshot)
npart = head.npart
if verbose:
print('Sub-snapshot {0:d}, DM particles = {1:d} \n'.format(
i, npart[ptype]))
if (DEBUG > 1 and i % 100 == 0):
print(
'Sub-snapshot {0:d}, DM particles = {1:d}, time = {2:%H:%M:%S} \n'
.format(i, npart[ptype], datetime.datetime.now()))
# read positions in Mpc/h
pos = readgadget.read_field(snapshot, "POS ", ptype)
# read velocities in km/s
if do_RSD:
vel = readgadget.read_field(snapshot, "VEL ", ptype)
# write galaxy data for each redshift bin into its own file
fname = lightcone_path + 'galaxy_lightcone.snap{0:02d}'.format(snap)
# open output file
if (i == 0):
mode = 'w' #open file in write mode for first file in snapshot
else:
mode = 'r+' #thereafter open in append mode
fo = h5py.File(fname, mode)
for oct in range(8):
#relocate origin to each corner of the simulation box for each octant
orig_x = oct % 2 * BoxSize
orig_y = oct // 2 % 2 * BoxSize
orig_z = oct // 4 * BoxSize
# translate particle positions to new origin for each octant
x = pos[::, 0] - orig_x
y = pos[::, 1] - orig_y
z = pos[::, 2] - orig_z
# calculate comoving radial distance, RA and Dec
r = np.sqrt(x * x + y * y + z * z)
dec = np.rad2deg(np.arcsin(z / r))
ra = np.rad2deg(np.arctan2(y, x))
# lookup redshift corresponding to this r
zz = d2z(r)
if do_RSD:
# Calculate radial velocity
vr = np.sqrt(vel[::, 0]**2 + vel[::, 1]**2 +
vel[::, 2]**2) * np.sign(vel[::, 0] + vel[::, 1] +
vel[::, 2])
# Calculate RSD factor
# Particle velocities u in internal velocity units (corresponds to km/sec if the default choice for the system of units is adopted).
# Peculiar velocities v are obtained by multiplying u with sqrt(a), i.e. v = u * sqrt(a). So v = u / sqrt(1+z)
f_RSD = np.sqrt(1 + zz) * vr / z2H(zz)
else:
f_RSD = np.zeros(len(r))
#Check whether particle within shell max and min
sn = 63 - snap
if (sn == 0):
F = [(r <= Dc_max[sn])]
else:
F = [(r > Dc_max[sn - 1]) & (r <= Dc_max[sn])]
f = tuple(F)
# create random luminosity value for each particle
ngal = len(pos)
L = P2L(np.random.random(ngal) * n)
# create dataset. Use f to filter only those galaxies within snapshot redshift boundaries
g = np.array(list(zip(r[f], ra[f], dec[f], zz[f], f_RSD[f], L[f])),
dtype=gal)
ds_name = 'octant_{0:01d}'.format(oct)
if (DEBUG > 3): print(ds_name)
# if filenum = 0 then create new datasets for each octant and set dataset atributes
if (i == 0):
gals = fo.create_dataset(
ds_name, data=g, dtype=gal, maxshape=(None, ), chunks=True
) # set maxshape = None to make resizeable and chunks = True to enable chunking
gals.attrs['max_z'] = z_max[sn]
if (sn == 0):
gals.attrs['min_z'] = 0
else:
gals.attrs['min_z'] = z_max[sn - 1]
gals.attrs['snap'] = snap
gals.attrs['octant'] = oct
gals.attrs['alpha'] = alpha
gals.attrs['phi_star'] = p_star
elif (len(g) > 0):
gals = fo[ds_name]
gals.resize(gals.shape[0] + len(g), axis=0)
gals[-len(g):] = g
# end of processing for this octant
fo.close()
if (DEBUG > 2):
print(fname, " completed, time:", datetime.datetime.now())
sys.stdout.flush()
# compute density field.
MASL.MA(pos, density, BoxSize, MAS)
num += pos.shape[0]
# All files read for snapshot
if (DEBUG > 0): print(fname, " completed, time:", datetime.datetime.now())
# Write density field to file
rho_avg = np.mean(density, dtype=np.float64)
density /= rho_avg
density -= 1.0
density.tofile(density_fname)
if verbose:
print(
'Density delta written to file for snap {0:d}, mean density = {1:04f}'
.format(snap, rho_avg))
# Calculate power spectrum from density
threads = 16
Pk = PKL.Pk(density, BoxSize, axis, MAS, threads)
print('Pk calculated')
#Save power spectra components in hdf5 file
fname = 'powerspec_{0:03d}.npy'.format(snap)
# open output file
fo = h5py.File(powerspec_path + fname, 'w')
# create datasets
atts = fo.create_dataset(
"attribs", dtype="f") # empty dataset for holding snapshot attributes
atts.attrs['z'] = redshift
atts.attrs['Omega_m'] = Omega_m
atts.attrs['Omega_l'] = Omega_l
# 1D P(k)
dset = fo.create_dataset('k1D', data=Pk.k1D)
dset = fo.create_dataset('Pk1D', data=Pk.Pk1D)
dset = fo.create_dataset('Nmodes1D', data=Pk.Nmodes1D)
# 2D P(k)
dset = fo.create_dataset('kpar', data=Pk.kpar)
dset = fo.create_dataset('kper', data=Pk.kper)
dset = fo.create_dataset('Pk2D', data=Pk.Pk2D)
dset = fo.create_dataset('Nmodes2D', data=Pk.Nmodes2D)
# 3D P(k)
dset = fo.create_dataset('k', data=Pk.k3D)
dset = fo.create_dataset('Pk0', data=Pk.Pk[:, 0])
dset = fo.create_dataset('Pk2', data=Pk.Pk[:, 1])
dset = fo.create_dataset('Pk4', data=Pk.Pk[:, 2])
dset = fo.create_dataset('Nmodes', data=Pk.Nmodes3D)
fo.close()
print('Power spectrum data written to file')
def density_field_gadget(snapshot_fname,
ptypes,
dims,
MAS='CIC',
do_RSD=False,
axis=0,
verbose=True):
start = time.time()
if verbose: print('\nComputing density field of particles', ptypes)
# declare the array hosting the density field
density = np.zeros((dims, dims, dims), dtype=np.float32)
# read relevant paramaters on the snapshot
head = readgadget.header(snapshot_fname)
BoxSize = head.boxsize / 1e3 #Mpc/h
Masses = head.massarr * 1e10 #Msun/h
Nall = head.nall
Ntotal = np.sum(Nall, dtype=np.int64)
filenum = head.filenum
Omega_m = head.omega_m
Omega_l = head.omega_l
redshift = head.redshift
fformat = head.format
Hubble = head.Hubble
if ptypes == [-1]: ptypes = [0, 1, 2, 3, 4, 5]
if len(ptypes) == 1: single_component = True
else: single_component = False
# do a loop over all files
num = 0.0
for i in range(filenum):
# find the name of the sub-snapshot
if filenum == 1: snapshot = snapshot_fname
else: snapshot = snapshot_fname + '.%d' % i
if fformat == 'hdf5': snapshot = snapshot + '.hdf5'
# find the local particles in the sub-snapshot
head = readgadget.header(snapshot)
npart = head.npart
# do a loop over all particle types
for ptype in ptypes:
if npart[ptype] == 0: continue
# read positions in Mpc/h
pos = readgadget.read_field(snapshot, "POS ", ptype) / 1e3
#pos = readsnap.read_block(snapshot,"POS ",parttype=ptype)/1e3
# read velocities in km/s and move particles to redshift-space
if do_RSD:
vel = readgadget.read_field(snapshot, "VEL ", ptype)
#vel = readsnap.read_block(snapshot,"VEL ",parttype=ptype)
RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift,
axis)
del vel
# compute density field. If multicomponent, read/find masses
if Masses[ptype] != 0:
if single_component:
MASL.MA(pos, density, BoxSize, MAS)
num += pos.shape[0]
else:
mass = np.ones(npart[ptype],
dtype=np.float32) * Masses[ptype]
MASL.MA(pos, density, BoxSize, MAS, W=mass)
num += np.sum(mass, dtype=np.float64)
else:
mass = readgadget.read_field(snapshot, "MASS", ptype) * 1e10
#mass = readsnap.read_block(snapshot,"MASS",
# parttype=ptype)*1e10 #Msun/h
MASL.MA(pos, density, BoxSize, MAS, W=mass)
num += np.sum(mass, dtype=np.float64)
if verbose:
print('%.8e should be equal to\n%.8e'\
%(np.sum(density, dtype=np.float64), num))
print('Time taken = %.2f seconds' % (time.time() - start))
return np.asarray(density)
root = '/n/hernquistfs3/IllustrisTNG/Runs/L75n1820TNG/output/'
################################# INPUT ########################################
Mmin = 3.7e8 #3e9 #3.7e8
Mmax = 1e14
bins = 60
fout = 'ratio_g_75Mpc_1820_UVB'
#fout = 'ratio_g_75Mpc_1820_UVB'
################################################################################
for snapnum in [17,21,25,33,50,99]:
# read header
snapshot = root + 'snapdir_%03d/snap_%03d'%(snapnum,snapnum)
header = readgadget.header(snapshot)
BoxSize = header.boxsize/1e3 #Mpc/h
redshift = header.redshift
print 'L = %.1f Mpc/h'%BoxSize
print 'z = %.1f'%redshift
halos = groupcat.loadHalos(root, snapnum,
fields=['GroupMassType','GroupMass',
'Group_R_TopHat200'])
halo_mass = halos['GroupMassType'][:]*1e10 #Msun/h
Mass = halos['GroupMass'][:]*1e10 #Msun/h
R = halos['Group_R_TopHat200'][:]/1e3 #Mpc/h
indexes = np.where(R>0.0)[0]
halo_mass = halo_mass[indexes]
