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]]))