def compute_powerspectrum(self, other, save=True): #{{{
if other is None:
self.__compute_powerspectrum()
if save:
self._save_powerspectrum()
else:
assert isinstance(other, Field)
assert np.allclose(self.BoxSize, other.BoxSize)
Pk = PKL.XPk([self.data, other.data], self.BoxSize, 0,
[self.MAS, other.MAS], ARGS.threads)
self.powerspectrum = {
'k': Pk.k3D,
'P': Pk.Pk[:, 0, 0],
}
other.powerspectrum = {
'k': Pk.k3D,
'P': Pk.Pk[:, 0, 1],
}
self.crosspower = {
'k': Pk.k3D,
'r':
Pk.XPk[:, 0, 0] / np.sqrt(Pk.Pk[:, 0, 0] * Pk.Pk[:, 0, 1]),
}
if save:
self._save_powerspectrum()
other._save_powerspectrum()
np.savez(self.summary_path + '%s.npz' % self.crosspowername,
**self.crosspower)
if ARGS.verbose:
print 'Computed powerspectrum in Field(%s)' % self.mode
for axis in [-1, 0, 1, 2]:
# read delta_c
delta_c = f[obj[axis]['name']][:]
delta_c /= np.mean(delta_c, dtype=np.float64)
delta_c -= 1.0
# read delta_n
delta_n = g[obj[axis]['name']][:]
delta_n /= np.mean(delta_n, dtype=np.float64)
delta_n -= 1.0
# compute auto- and cross-Pk
Pk = PKL.XPk([delta_c, delta_n],
BoxSize,
axis=obj[axis]['axis'],
MAS=['CIC', 'CIC'],
threads=16)
del delta_c, delta_n
# save results to file
np.savetxt(
'Pk_c%sz=%.1f.txt' % (obj[axis]['output'], z),
np.transpose(
[Pk.k3D, Pk.Pk[:, 0, 0], Pk.Pk[:, 1, 0], Pk.Pk[:, 2, 0]]))
np.savetxt(
'Pk_n%sz=%.1f.txt' % (obj[axis]['output'], z),
np.transpose(
[Pk.k3D, Pk.Pk[:, 0, 1], Pk.Pk[:, 1, 1], Pk.Pk[:, 2, 1]]))
np.savetxt(
'Pk_cn%sz=%.1f.txt' % (obj[axis]['output'], z),
axis)
delta_c /= np.mean(delta_c, dtype=np.float64)
delta_c -= 1.0
# compute delta_h
delta_h = np.zeros((grid, grid, grid), dtype=np.float32)
FoF = readfof.FoF_catalog(f2,
snapnum,
long_ids=False,
swap=False,
SFR=False,
read_IDs=False)
pos_h = FoF.GroupPos / 1e3 #Mpc/h
mass = FoF.GroupMass * 1e10 #Msun/h
indexes = np.where(mass > Mmin)[0]
pos_h = pos_h[indexes]
del indexes
MASL.MA(pos_h, delta_h, BoxSize, MAS)
delta_h /= np.mean(delta_h, dtype=np.float64)
delta_h -= 1.0
# compute power spectra
Pk = PKL.XPk([delta_c, delta_h], BoxSize, axis, [MAS, MAS], threads)
b[2 * i +
pair] = (Pk.Pk[:, 0, 1] - BoxSize**3 / len(pos_h)) / Pk.Pk[:, 0, 0]
fout = '%s/b_z=0.txt' % (cosmo)
np.savetxt(fout, np.transpose([Pk.k3D, np.mean(b, axis=0), np.std(b, axis=0)]))
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 = readsnap.snapshot_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 = readsnap.read_block(snapshot_fname,"MASS",parttype=0)*1e10
Omega_g = np.sum(mass,dtype=np.float64)/BoxSize**3/rho_crit
mass = readsnap.read_block(snapshot_fname,"MASS",parttype=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 = readsnap.read_block(snapshot_fname,"POS ",parttype=ptype)/1e3
# move particle positions to redshift-space
if do_RSD:
vel = readsnap.read_block(snapshot_fname,"VEL ",parttype=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]))
##############################################################################
for z in redshifts:
f = h5py.File('fields_z=%.1f.hdf5' % z, 'r')
delta_HI = f['delta_HI'][:]
delta_m = f['delta_m'][:]
f.close()
Omega_HI = np.sum(delta_HI, dtype=np.float64) / (BoxSize**3 * rho_crit)
Omega_m = np.sum(delta_m, dtype=np.float64) / (BoxSize**3 * rho_crit)
print 'z=%.1f ------> Omega_HI = %.5f ---> Omega_m = %.4f'\
%(z,Omega_HI,Omega_m)
delta_HI /= np.mean(delta_HI, dtype=np.float64)
delta_HI -= 1.0
delta_m /= np.mean(delta_m, dtype=np.float64)
delta_m -= 1.0
Pk = PKL.XPk([delta_HI, delta_m],
BoxSize,
axis=0,
MAS=['CIC', 'CIC'],
threads=8)
np.savetxt('Pk_HI_z=%.1f.txt' % z, np.transpose([Pk.k3D, Pk.Pk[:, 0, 0]]))
np.savetxt('Pk_m_z=%.1f.txt' % z, np.transpose([Pk.k3D, Pk.Pk[:, 0, 1]]))
np.savetxt('Pk_HI-m_z=%.1f.txt' % z,
np.transpose([Pk.k3D, Pk.XPk[:, 0, 0]]))
