def PlotRhoVsTemp(base, num, arepo=0, BINS=200, Omegab=0.044, xmin=-3., xmax=7., ymin=2., ymax=8., format='.eps'): if arepo > 0: filename=base+'snap_arepo_'+str(num).zfill(3) else: filename=base+'snap_gadget_'+str(num).zfill(3) head=rs.snapshot_header(filename) mass=np.float64(rs.read_block(filename, "MASS", parttype=0, arepo=arepo)) rho=np.float64(rs.read_block(filename, "RHO ", parttype=0, arepo=arepo)) u=np.float64(rs.read_block(filename, "U ", parttype=0, arepo=arepo)) Nelec=np.float64(rs.read_block(filename, "NE ", parttype=0, arepo=arepo)) temp=co.GetTemp(u, Nelec, 5./3.) rho_b=Omegab*co.GetRhoCrit() rho/=rho_b print "z = ", head.redshift print "min/max of T [K] = ", min(temp), max(temp) print "min/max of rho/rho_b = ", min(rho), max(rho) rho=np.log10(rho) temp=np.log10(temp) if (xmin==0.) & (ymin==0.) & (xmax==0.) & (ymax==0.): print "range not specified -> adjusting min/max" xmin=min(rho) xmax=max(rho) ymin=min(temp) ymax=max(temp) Z,x,y=np.histogram2d(rho,temp, range=[[xmin,xmax],[ymin,ymax]], weights=mass, bins=BINS, normed=True) Z=np.log10(Z) Zmin=Z[Z>-np.inf].min() Zmax=Z.max() print "min/max of log10(histogram) = ", Zmin, Zmax fig = plt.figure(1, figsize=(10.0,10.0)) ax = fig.add_subplot(1,1,1) im=ax.imshow(Z.T, vmin=Zmin, vmax=Zmax, origin='lower',interpolation='nearest', extent=[xmin, xmax, ymin, ymax], cmap=cm.get_cmap('jet')) ax.contour(Z.T,origin='lower',extent=[xmin, xmax, ymin, ymax], colors='black', vmin=Zmin, vmax=Zmax) x0, x1 = ax.get_xlim() y0, y1 = ax.get_ylim() ax.set_aspect((x1-x0)/(y1-y0)) ax.set_xlabel(r'log $\rho/\rho_{b}$', fontsize=20) ax.set_ylabel('log T [K]', fontsize=20) plt.colorbar(im, shrink=0.5) if arepo > 0: plt.suptitle('Arepo z='+str(round(head.redshift,2))) plt.savefig('Rho_vs_T_arepo_'+str(num).zfill(3)+format) else: plt.suptitle('Gadget z='+str(round(head.redshift,2))) plt.savefig('Rho_vs_T_gagdet_'+str(num).zfill(3)+format) fig.clf()
def Pk_comp(snapshot_fname,ptype,dims,do_RSD,axis,cpus,folder_out): # read relevant paramaters on the header print 'Computing power spectrum...' head = readsnap.snapshot_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 = readsnap.read_block(snapshot_fname,"POS ",parttype=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 = readsnap.read_block(snapshot_fname,"VEL ",parttype=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 = readsnap.read_block(snapshot_fname,"MASS",parttype=-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 read_field(snapshot, block, ptype): filename, fformat = fname_format(snapshot) head = header(filename) Masses = head.massarr * 1e10 #Msun/h Npart = head.npart #number of particles in the subfile Nall = head.nall #total number of particles in the snapshot if fformat == "binary": return readsnap.read_block(filename, block, parttype=ptype) else: prefix = 'PartType%d/' % ptype f = h5py.File(filename, 'r') if block == "POS ": suffix = "Coordinates" elif block == "MASS": suffix = "Masses" elif block == "ID ": suffix = "ParticleIDs" elif block == "VEL ": suffix = "Velocities" else: raise Exception('block not implemented in readgadget!') if '%s%s' % (prefix, suffix) not in f: if Masses[ptype] != 0.0: array = np.ones(Npart[ptype], np.float32) * Masses[ptype] else: raise Exception('Problem reading the block %s' % block) else: array = f[prefix + suffix][:] f.close() if block == "VEL ": array *= np.sqrt(head.time) if block == "POS " and array.dtype == np.float64: array = array.astype(np.float32) return array
def visualize_mesh(basename, num, Lx, Ly, mi, ma, arepo=1, format=".eps"): filename=basename+str(num).zfill(3) print filename rho = rs.read_block(filename,"RHO ", parttype=0, arepo=arepo) filename='voronoi_mesh_'+str(num).zfill(3) f = open(filename,'rb') ngas=np.fromfile(f,dtype=np.int32,count=1) nel=np.fromfile(f,dtype=np.int32,count=1) nedgepoints=np.fromfile(f,dtype=np.int32,count=1) nedges=np.fromfile(f,dtype=np.int32,count=ngas[0]) nedges_offest=np.fromfile(f,dtype=np.int32,count=ngas[0]) edgelist=np.fromfile(f,dtype=np.int32,count=nel[0]) points=np.fromfile(f,dtype=np.dtype((np.float32,2)),count=nedgepoints[0]) f.close() print "Number = ", num print "Voronoi Cells = ", ngas[0] print "nel = ", nel[0] print "Edge points = ", nedgepoints[0] if (Lx>Ly): fig = plt.figure(1, figsize=(Lx/Ly*2.5,2.5)) else: fig = plt.figure(1, figsize=(10.0,10.0)) ax = fig.add_subplot(1,1,1) print "min/max of rho = ", min(rho),max(rho) rho[rho > ma] = ma rho[rho < mi] = mi for i in range(0,ngas[0]): x = points[edgelist[nedges_offest[i]:nedges_offest[i]+nedges[i]],0] y = points[edgelist[nedges_offest[i]:nedges_offest[i]+nedges[i]],1] cmap=get_cmap("jet") co = cmap( (rho[i]-mi)/(ma-mi) ) ax.fill(np.append(x,x[0]), np.append(y,y[0]), color=co, edgecolor='white') if shape(np.nonzero((x < 0.0) | (x > Lx) | (y < 0.0) | (y > Ly )))[1] > 0: for dx in range(-1,2): for dy in range(-1,2): ax.fill(np.append(x,x[0])+dx*Lx,np.append(y,y[0])+dy*Ly,color=co, edgecolor='white') ax.axis([0.0,Lx,0.0,Ly]) ax.set_xlabel('x') ax.set_ylabel('y') ax.xaxis.set_major_locator(MultipleLocator(0.5)) ax.yaxis.set_major_locator(MultipleLocator(0.5)) plt.savefig("image_"+str(num).zfill(3)+format) clf()
def read_snapshot(snapshot, printOut=False): ptype = [1] #[1](CDM), [2](neutrinos) or [1,2](CDM+neutrinos) header = rs.snapshot_header(snapshot) # reads snapshot header coords = rs.read_block( snapshot, "POS " ) # reads mass for particles of type 5, using block names should work for both format 1 and 2 snapshots ids = rs.read_block( snapshot, "ID " ) # reads mass for particles of type 5, using block names should work for both format 1 and 2 snapshots if printOut == True: print("coordinates for", coords.size, "particles read") print(coords[0:10]) print("ids for", ids.size, "particles read") print(ids[0:10]) return [ids, coords]
def read_block(snapshot, block, ptype, verbose=False): # find the format of the file and read header filename, fformat = fname_format(snapshot) head = header(filename) Nall = head.nall filenum = head.filenum # find the total number of particles to read Ntotal = 0 for i in ptype: Ntotal += Nall[i] # find the dtype of the block if block=="POS ": dtype=np.dtype((np.float32,3)) elif block=="VEL ": dtype=np.dtype((np.float32,3)) elif block=="MASS": dtype=np.float32 elif block=="ID ": dtype=read_field(filename, block, ptype[0]).dtype else: raise Exception('block not implemented in readgadget!') # define the array containing the data array = np.zeros(Ntotal, dtype=dtype) # do a loop over the different particle types offset = 0 for pt in ptype: # format I or format II Gadget files if fformat=="binary": array[offset:offset+Nall[pt]] = \ readsnap.read_block(snapshot, block, pt, verbose=verbose) offset += Nall[pt] # single files (either binary or hdf5) elif filenum==1: array[offset:offset+Nall[pt]] = read_field(snapshot, block, pt) offset += Nall[pt] # multi-file hdf5 snapshot else: # do a loop over the different files for i in range(filenum): # find the name of the file to read filename = '%s.%d.hdf5'%(snapshot,i) # read number of particles in the file and read the data npart = header(filename).npart[pt] array[offset:offset+npart] = read_field(filename, block, pt) offset += npart if offset!=Ntotal: raise Exception('not all particles read!!!!') return array
def read_block(snapshot, block, ptype, verbose=False): # find the format of the file and read header filename, fformat = fname_format(snapshot) head = header(filename) Nall = head.nall filenum = head.filenum # find the total number of particles to read Ntotal = 0 for i in ptype: Ntotal += Nall[i] # find the dtype of the block if block=="POS ": dtype=np.dtype((np.float32,3)) elif block=="VEL ": dtype=np.dtype((np.float32,3)) elif block=="MASS": dtype=np.float32 elif block=="ID ": dtype=read_field(filename, block, ptype[0]).dtype else: raise Exception('block not implemented in readgadget!') # define the array containing the data array = np.zeros(Ntotal, dtype=dtype) # do a loop over the different particle types offset = 0 for pt in ptype: # format I or format II Gadget files if fformat=="binary": array[offset:offset+Nall[pt]] = \ readsnap.read_block(snapshot, block, pt, verbose=verbose) offset += Nall[pt] # single files (either binary or hdf5) elif filenum==1: array[offset:offset+Nall[pt]] = read_field(snapshot, block, pt) offset += Nall[pt] # multi-file hdf5 snapshot else: # do a loop over the different files for i in xrange(filenum): # find the name of the file to read filename = '%s.%d.hdf5'%(snapshot,i) # read number of particles in the file and read the data npart = header(filename).npart[pt] array[offset:offset+npart] = read_field(filename, block, pt) offset += npart if offset!=Ntotal: raise Exception('not all particles read!!!!') return array
def read(self, blocklist, parttype=-1): '''Reading method to load particle data from snapshots. my_snapshot.read(blocklist, parttype = [0,1]) Arguments: blocklist List of hdf5 block names to be read (see: 'my_snapshot.show_snapshot_contents()') parttype List of parttypes for which the data should be read, optional, default '-1' (read all types) Usage Example: my_snapshot.read(['Velocities', 'Coordinates'], parttype = [0,1]) Will read coordinates and velocities for gas and dm from the snapshot. The data is accessible through my_snapshot.data ''' print("Reading " + str(blocklist) + "from snapshot") if type(blocklist) == str: blocklist = [blocklist] if not self.hdf5: #use the old method for block in blocklist: if block == "POS ": self.pos = rs.read_block(self.snapname, "POS ", parttype=parttype) / self.const.h self.data["POS "] = self.pos elif block == "VEL ": self.vel = rs.read_block(self.snapname, "VEL ", parttype=parttype) self.data["VEL "] = self.vel elif block == "MASS": self.mass = rs.read_block( self.snapname, "MASS", parttype=parttype) * 1e10 / self.const.h self.data["MASS"] = self.mass else: self.data[block] = rs.read_block(self.snapname, block, parttype=parttype) else: #use the faster hdf5 reading routines self.read_hdf5(blocklist, parttype)
def read_field(snapshot, block, ptype): filename, fformat = fname_format(snapshot) head = header(filename) if fformat=="binary": return readsnap.read_block(filename, block, parttype=ptype) else: prefix = 'PartType%d/'%ptype f = h5py.File(filename, 'r') if block=="POS ": suffix = "Coordinates" elif block=="MASS": suffix = "Masses" elif block=="ID ": suffix = "ParticleIDs" elif block=="VEL ": suffix = "Velocities" else: raise Exception('block not implemented in readgadget!') array = f[prefix+suffix][:]; f.close() if block=="VEL ": array *= np.sqrt(head.time) if block=="POS " and array.dtype==np.float64: array = array.astype(np.float32) return array
def cell_mass_dist(basename, num, arepo=1, bins=100, format=".eps"): filename=basename+str(num).zfill(3) mass = rs.read_block(filename,"MASS", parttype=0,arepo=arepo) meanmass=mass.mean() print "mean cell mass = ", meanmass print "min/max of cell mass = ", mass.min(),mass.max() fig = plt.figure(1, figsize=(10.0,10.0)) ax = fig.add_subplot(1,1,1) # the histogram of the data n, bins, patches = plt.hist(np.log10(mass/meanmass), bins, normed=1, facecolor='blue') ax.set_xlabel('log[m/<m>]') ax.set_ylabel('df / dlog[m/<m>]') plt.savefig("cell_mass_dist_"+str(num).zfill(3)+format) clf()
def read_field(snapshot, block, ptype): filename, fformat = fname_format(snapshot) head = header(filename) if fformat == "binary": return readsnap.read_block(filename, block, parttype=ptype) else: prefix = 'PartType%d/' % ptype f = h5py.File(filename, 'r') if block == "POS ": suffix = "Coordinates" elif block == "MASS": suffix = "Masses" elif block == "ID ": suffix = "ParticleIDs" elif block == "VEL ": suffix = "Velocities" else: raise Exception('block not implemented in readgadget!') array = f[prefix + suffix][:] f.close() if block == "VEL ": array *= np.sqrt(head.time) if block == "POS " and array.dtype == np.float64: array = array.astype(np.float32) return array
def star_mass_dist(basename, num, arepo=1, bins=100, format=".eps"): filename=basename+str(num).zfill(3) head=rs.snapshot_header(filename) mass = rs.read_block(filename,"MASS", parttype=4,arepo=arepo) print mass meanmass=mass.mean() print "mean star mass = ", meanmass print "min/max of star mass = ", mass.min(),mass.max() fig = plt.figure(1, figsize=(10.0,10.0)) ax = fig.add_subplot(1,1,1) # the histogram of the data n, bins, patches = plt.hist(np.log10(mass/meanmass), bins, normed=1, facecolor='blue') ax.set_xlabel('log[m/<m>]') ax.set_ylabel('df / dlog[m/<m>]') plt.suptitle('z='+str(round(head.redshift,2))) plt.savefig("star_mass_dist_"+str(num).zfill(3)+format) fig.clf()
# 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) #h*km/s/Mpc h = head.hubble # read the density, electron fraction and internal energy # rho units: h^2 Msun / Mpc^3 rho = readsnap.read_block(snapshot_fname, "RHO ", parttype=0) * 1e10 / 1e-9 ne = readsnap.read_block(snapshot_fname, "NE ", parttype=0) #electron fraction U = readsnap.read_block(snapshot_fname, "U ", parttype=0) #(km/s)^2 # compute the mean molecular weight yhelium = (1.0 - 0.76) / (4.0 * 0.76) mean_mol_weight = (1.0 + 4.0 * yhelium) / (1.0 + yhelium + ne) del ne # compute the temperature of the gas particles T = U * (gamma - 1.0) * mH * mean_mol_weight / kB del U, mean_mol_weight T = T.astype(np.float64) print '%.3e < T[k] < %.3e' % (np.min(T), np.max(T))
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) #h*km/s/Mpc h = head.hubble #find the total number of particles in the simulation Ntotal = np.sum(Nall, dtype=np.uint64) print 'Total number of particles in the simulation:', Ntotal #sort the pos array ID_unsort = readsnap.read_block(snapshot_fname, "ID ", parttype=-1) - 1 pos_unsort = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) / 1e3 #Mpc/h pos = np.empty((Ntotal, 3), dtype=np.float32) pos[ID_unsort] = pos_unsort del pos_unsort, ID_unsort #sort the R array ID_unsort = readsnap.read_block(snapshot_fname, "ID ", parttype=0) - 1 R_unsort = readsnap.read_block(snapshot_fname, "HSML", parttype=0) / 1e3 #Mpc/h R = np.zeros(Ntotal, dtype=np.float32) R[ID_unsort] = R_unsort del R_unsort, ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned
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) #h*km/s/Mpc h = head.hubble #compute the values of Omega_CDM and Omega_B Omega_cdm = Nall[1] * Masses[1] / BoxSize**3 / rho_crit Omega_b = Omega_m - Omega_cdm print '\nOmega_CDM = %.3f\nOmega_B = %0.3f\nOmega_M = %.3f\n'\ %(Omega_cdm,Omega_b,Omega_m) #read the positions of all the particles pos = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) / 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 all the particles vel = readsnap.read_block(snapshot_fname, "VEL ", parttype=-1) #kms if do_RSD: print 'moving particles to redshift-space' RSD(pos[:, axis], vel[:, axis], Hubble, redshift) #read the masses of all the particles M = readsnap.read_block(snapshot_fname, "MASS", parttype=-1) * 1e10 #Msun/h print '%.3e < M [Msun/h] < %.3e' % (np.min(M), np.max(M)) print 'Omega_m = %.3f\n' % (np.sum(M, dtype=np.float64) / rho_crit /
#obtain the positions of the random particles reading/creating a random catalogue pos_r,RR_name = CFL.create_random_catalogue(random_points,Rmin,Rmax,bins,BoxSize) #we set here the actions DD_action = 'compute' RR_action = 'read' #if needed, the RR pairs are computed above DR_action = 'compute' #Only the master will read the positions of the galaxies pos_g = None if myrank==0: #read positions, velocities and IDs of DM particles: sort the IDs array DM_pos = readsnap.read_block(snapshot_fname,"POS ",parttype=-1) #kpc/h DM_vel = readsnap.read_block(snapshot_fname,"VEL ",parttype=-1) #km/s #IDs should go from 0 to N-1, instead from 1 to N DM_ids = readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 if np.min(DM_ids)!=0 or np.max(DM_ids)!=(len(DM_pos)-1): print 'Error!!!!'; print 'IDs should go from 0 to N-1' print len(DM_ids),np.min(DM_ids),np.max(DM_ids) sorted_ids = DM_ids.argsort(axis=0); del DM_ids #the particle whose ID is N is located in the position sorted_ids[N] #i.e. DM_ids[sorted_ids[N]]=N #the position of the particle whose ID is N would be: #DM_pos[sorted_ids[N]] #read the IDs of the particles belonging to the CDM halos #again the IDs should go from 0 to N-1 halos_ID = readsubf.subf_ids(groups_fname,groups_number,0,0,
snapnum = LM['snapnum'][ll] zl = LM['zl'][ll] # Only load new particle data if lens is at another snapshot if (previous_snapnum != snapnum): rks_file = '/cosma5/data/dp004/dc-beck3/rockstar/'+sim_phy[sim]+ \ sim_name[sim]+'/halos_' + str(snapnum)+'.dat' hdata = pd.read_csv(rks_file, sep='\s+', skiprows=np.arange(1, 16)) # Load Particle Properties # 0 Gas, 1 DM, 4 Star[Star=+time & Wind=-time], 5 BH snap = snapfile % (snapnum, snapnum) #gas_pos = readsnap.read_block(snap, 'POS ', parttype=0)*scale #gas_vel = readsnap.read_block(snap, 'VEL ', parttype=0) star_pos = readsnap.read_block(snap, 'POS ', parttype=4) * scale star_age = readsnap.read_block(snap, 'AGE ', parttype=4) star_vel = readsnap.read_block(snap, 'VEL ', parttype=4) star_mass = readsnap.read_block(snap, 'MASS', parttype=4) * 1e10 / h star_pos = star_pos[star_age >= 0] star_vel = star_vel[star_age >= 0] star_mass = star_mass[star_age >= 0] del star_age #star_pos = np.vstack((star_pos, gas_pos)) #del gas_pos #star_vel = np.vstack((star_vel, gas_vel)) #del gas_vel previous_snapnum = snapnum # Load Halo 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) #h*km/s/Mpc h=head.hubble #find the total number of particles in the simulation Ntotal=np.sum(Nall,dtype=np.uint64) print 'Total number of particles in the simulation =',Ntotal #sort the pos and vel array ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 #normalized print 'sorting the POS array...' pos_unsort=readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/1e3 #Mpc/h pos=np.empty((Ntotal,3),dtype=np.float32); pos[ID_unsort]=pos_unsort; del pos_unsort if do_RSD: print 'sorting the VEL array...' vel_unsort=readsnap.read_block(snapshot_fname,"VEL ",parttype=-1) #km/s vel=np.empty((Ntotal,3),dtype=np.float32); vel[ID_unsort]=vel_unsort; del vel_unsort del ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned if method=='Dave': [IDs,M_HI]=HIL.Dave_HI_assignment(snapshot_fname,HI_frac,fac) elif method=='method_1': [IDs,M_HI]=HIL.method_1_HI_assignment(snapshot_fname,HI_frac,Omega_HI_ref) elif method=='Barnes':
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) #h*km/s/Mpc h = head.hubble #find the total number of particles in the simulation Ntotal = np.sum(Nall,dtype=np.uint64) print 'Total number of particles in the simulation =',Ntotal #sort the pos and vel array ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 #normalized print 'sorting the POS array...' pos_unsort=readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/1e3 #Mpc/h pos=np.empty((Ntotal,3),dtype=np.float32); pos[ID_unsort]=pos_unsort; del pos_unsort if Pk_HI_redshift_space: print 'sorting the VEL array...' vel_unsort=readsnap.read_block(snapshot_fname,"VEL ",parttype=-1) #km/s vel=np.empty((Ntotal,3),dtype=np.float32); vel[ID_unsort]=vel_unsort; del vel_unsort del ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned if method == 'Dave': [IDs,M_HI]=HIL.Dave_HI_assignment(snapshot_fname,HI_frac,fac) elif method=='method_1':
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 #read positions and masses of the CDM particles pos = readsnap.read_block(snapshot_fname, "POS ", parttype=1) / 1e3 #Mpc/h mass = readsnap.read_block(snapshot_fname, "MASS", parttype=1) * 1e10 #Msun/h #compute the mean mass in each cell of the slice mass_density = np.sum(mass, dtype=np.float64) * 1.0 / BoxSize**3 #mass/(Mpc/h)^3 V_cell = BoxSize_slice**2 * depth * 1.0 / dims**2 #slice cell volume in (Mpc/h)^3 mean_mass = mass_density * V_cell #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] mass = mass[indexes] print 'Coordinates of the particles in the slice:'
def HaloProfiles(basename, num, centre, r200, rmin=0.05, rmax=10.0, bins=50, arepo=1, gamma=5./3., format=".eps"): filename=basename+str(num).zfill(3) head=rs.snapshot_header(filename) mass_gas = rs.read_block(filename,"MASS", parttype=0,arepo=arepo).astype('float64') mass_DM = rs.read_block(filename,"MASS", parttype=1,arepo=arepo).astype('float64') pos_gas = rs.read_block(filename,"POS ", parttype=0,arepo=arepo).astype('float64') pos_DM = rs.read_block(filename,"POS ", parttype=1,arepo=arepo).astype('float64') u = rs.read_block(filename,"U ", parttype=0,arepo=arepo).astype('float64') rho = rs.read_block(filename,"RHO ", parttype=0,arepo=arepo).astype('float64') Nele = rs.read_block(filename,"NE ", parttype=0,arepo=arepo).astype('float64') print "Centre = ", centre print "R200 = ", r200 print "rmin/rmax = ", rmin, rmax x=pos_gas[:,0] - centre[0] y=pos_gas[:,1] - centre[1] z=pos_gas[:,2] - centre[2] r_gas=np.sqrt(x**2. + y**2. + z**2.) / r200 x=pos_DM[:,0] - centre[0] y=pos_DM[:,1] - centre[1] z=pos_DM[:,2] - centre[2] r_DM=np.sqrt(x**2. + y**2. + z**2.) / r200 rmin=np.log10(rmin) rmax=np.log10(rmax) dlog10=(rmax-rmin)/bins rho_DM_bin=np.zeros(bins) rho_gas_bin=np.zeros(bins) temp_bin=np.zeros(bins) entropy_bin=np.zeros(bins) rbinm=10.**((np.arange(bins)+0.5)*dlog10 + rmin) for n in range(0,bins): r1=10.**((n+0.)*dlog10 + rmin) r2=10.**((n+1.)*dlog10 + rmin) index_gas=((r_gas>r1) & (r_gas<r2)).nonzero() index_DM=((r_DM>r1) & (r_DM<r2)).nonzero() totmass_gas=mass_gas[index_gas].sum() totmass_DM=mass_DM[index_DM].sum() rho_gas_bin[n]=totmass_gas/(4.*np.pi/3.*(r2**3.-r1**3.)*r200**3.) rho_DM_bin[n]=totmass_DM/(4.*np.pi/3.*(r2**3.-r1**3.)*r200**3.) if (totmass_gas > 0.): entropy_bin[n]=np.average(co.GetEntropy(u[index_gas],rho[index_gas],gamma), weights=mass_gas[index_gas]) temp_bin[n]=np.average(co.GetTemp(u[index_gas],Nele[index_gas],gamma), weights=mass_gas[index_gas]) fig = plt.figure(1, figsize=(10.0,10.0)) ax = fig.add_subplot(2,2,1) ax.set_xlabel('$r/r_{200}$') ax.set_ylabel(r'$\rho_{DM}$ [$h^2$ M$_\odot$ Kpc$^{-3}$]') ax.loglog() ax.plot(rbinm, 10.0**10.0*rho_DM_bin) ax.set_xlim((10.0**rmin,10.0**rmax)) ax = fig.add_subplot(2,2,2) ax.set_xlabel('$r/r_{200}$') ax.set_ylabel(r'$\rho_{gas}$ [$h^2$ M$_\odot$ Kpc$^{-3}$]') ax.loglog() ax.plot(rbinm, 10.0**10.0*rho_gas_bin) ax.set_xlim((10.0**rmin,10.0**rmax)) ax = fig.add_subplot(2,2,3) ax.set_xlabel('$r/r_{200}$') ax.set_ylabel('$T_{gas}$ [K]') ax.loglog() ax.plot(rbinm, temp_bin) ax.set_xlim((10.0**rmin,10.0**rmax)) ax = fig.add_subplot(2,2,4) ax.set_xlabel('$r/r_{200}$') ax.set_ylabel('Entropy') ax.loglog() ax.plot(rbinm, entropy_bin) ax.set_xlim((10.0**rmin,10.0**rmax)) plt.savefig("HaloProfiles_"+str(num).zfill(3)+format)
# 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) #h*km/s/Mpc h = head.hubble # read the density, electron fraction and internal energy # rho units: h^2 Msun / Mpc^3 rho = readsnap.read_block(snapshot_fname,"RHO ",parttype=0)*1e10/1e-9 ne = readsnap.read_block(snapshot_fname,"NE ",parttype=0) #electron fraction U = readsnap.read_block(snapshot_fname,"U ",parttype=0) #(km/s)^2 # compute the mean molecular weight yhelium = (1.0-0.76)/(4.0*0.76) mean_mol_weight = (1.0+4.0*yhelium)/(1.0+yhelium+ne); del ne # compute the temperature of the gas particles T = U*(gamma-1.0)*mH*mean_mol_weight/kB; del U, mean_mol_weight T = T.astype(np.float64) print '%.3e < T[k] < %.3e'%(np.min(T),np.max(T)) mean_rho_b = Omega_b*rho_crit rho_overdensity = rho/mean_rho_b; del rho
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 = readsnap.snapshot_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 = readsnap.read_block(snap, "POS ", parttype=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 = readsnap.read_block(snap, "MASS", parttype=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
######################################################################### # 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 ######################################################################### ######################################################################### pos = readsnap.read_block(snapshot_fname,"POS ",parttype=1)/1e3 #Mpc/h vel = readsnap.read_block(snapshot_fname,"VEL ",parttype=1) #km/s ######################################################################### ######################################################################### # read positions and velocities of halos FoF = readfof.FoF_catalog(snapdir,snapnum,long_ids=False, swap=False,SFR=False,read_IDs=True) pos_h = FoF.GroupPos/1e3 #Mpc/h mass = FoF.GroupMass*1e10 #Msun/h vel_h = FoF.GroupVel*(1.0+redshift) #km/s indexes = np.where(mass>Mmin)[0] pos_h = pos_h[indexes]; vel_h = vel_h[indexes]; del indexes #########################################################################
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) #h*km/s/Mpc h = head.hubble #find the total number of particles in the simulation Ntotal = np.sum(Nall, dtype=np.uint64) print 'Total number of particles in the simulation =', Ntotal #sort the pos and vel array ID_unsort = readsnap.read_block(snapshot_fname, "ID ", parttype=-1) - 1 #normalized print 'sorting the POS array...' pos_unsort = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) / 1e3 #Mpc/h pos = np.empty((Ntotal, 3), dtype=np.float32) pos[ID_unsort] = pos_unsort del pos_unsort if Pk_HI_redshift_space: print 'sorting the VEL array...' vel_unsort = readsnap.read_block(snapshot_fname, "VEL ", parttype=-1) #km/s vel = np.empty((Ntotal, 3), dtype=np.float32) vel[ID_unsort] = vel_unsort del vel_unsort del ID_unsort
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) #h*km/s/Mpc h=head.hubble #find the total number of particles in the simulation Ntotal=np.sum(Nall,dtype=np.uint64) print 'Total number of particles in the simulation:',Ntotal #sort the pos array ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 #normalized pos_unsort=readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/1e3 #Mpc/h pos=np.empty((Ntotal,3),dtype=np.float32); pos[ID_unsort]=pos_unsort del pos_unsort, ID_unsort #sort the R array (note that only gas particles have an associated R) ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=0)-1 #normalized R_unsort=readsnap.read_block(snapshot_fname,"HSML",parttype=0)/1e3 #Mpc/h R=np.zeros(Ntotal,dtype=np.float32); R[ID_unsort]=R_unsort del R_unsort, ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned if method=='Dave': [IDs,M_HI]=HIL.Dave_HI_assignment(snapshot_fname,HI_frac,fac) elif method=='method_1': [IDs,M_HI]=HIL.method_1_HI_assignment(snapshot_fname,HI_frac,Omega_HI_ref)
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]))
Omega_l = head.omega_l redshift = head.redshift Hubble = 100.0 * np.sqrt(Omega_m * (1.0 + redshift)**3 + Omega_l) #h*km/s/Mpc h = head.hubble #split the particle IDs among CDM, gas and stars and also among enviroment indexes = HIL.particle_indexes(snapshot_fname, groups_fname, groups_number, long_ids_flag, SFR_flag, mass_interval, min_mass, max_mass) #find the total number of particles in the simulation Ntotal = np.sum(Nall, dtype=np.uint64) print 'Total number of particles in the simulation =', Ntotal #sort the pos array ID_unsort = readsnap.read_block(snapshot_fname, "ID ", parttype=-1) - 1 #normalized pos_unsort = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) / 1e3 #Mpc/h pos = np.empty((Ntotal, 3), dtype=np.float32) pos[ID_unsort] = pos_unsort #sort the SPH radii array (only required if SPH_gas used) if Pk_method == 'SPH': ID_unsort = readsnap.read_block(snapshot_fname, "ID ", parttype=0) - 1 #normalized radii_unsort = readsnap.read_block(snapshot_fname, "HSML", parttype=0) / 1e3 #Mpc/h radii = np.empty(Ntotal, dtype=np.float32) radii[ID_unsort] = radii_unsort del radii_unsort, ID_unsort
#################################### INPUT #################################### snapshot_fname = '../ics' bins = 100 #number of bins for the distribution # parameters for the FD distribution Mnu = 0.6 #eV h_planck = 6.582e-16 #eV*s kB = 8.617e-5 #eV/K c = 3e5 #km/s Tnu = 1.95 #K ############################################################################### ########## fraction from simulation ########### # read snapshot redshift and neutrino velocities z = readsnap.snapshot_header(snapshot_fname).redshift vel = readsnap.read_block(snapshot_fname, "VEL ", parttype=2) #km/s # compute velocity modulus V = np.sqrt(vel[:, 0]**2 + vel[:, 1]**2 + vel[:, 2]**2) del vel # define the velocity intervals, their mean value and their widths vel_min, vel_max = np.min(V), np.max(V) if vel_min == 0.0: vel_min = 1e-3 vel_intervals = np.logspace(np.log10(vel_min), np.log10(vel_max), bins + 1) dV = vel_intervals[1:] - vel_intervals[:-1] #km/s V_mean = 0.5 * (vel_intervals[1:] + vel_intervals[:-1]) #km/s # compute the franction of neutrinos within each velocity bin hist = (np.histogram(V, bins=vel_intervals)[0]) * 1.0 / len(V) ###############################################
def compute_Pk(snapshot_fname,dims,do_RSD,axis,hydro): # 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) #h*km/s/Mpc h = head.hubble z = '%.3f'%redshift f_out = 'Pk_m_z='+z+'.dat' # compute the values of Omega_CDM and Omega_B Omega_cdm = Nall[1]*Masses[1]/BoxSize**3/rho_crit Omega_nu = Nall[2]*Masses[2]/BoxSize**3/rho_crit Omega_b = Omega_m-Omega_cdm-Omega_nu print '\nOmega_CDM = %.4f\nOmega_B = %0.4f\nOmega_NU = %.4f'\ %(Omega_cdm,Omega_b,Omega_nu) print 'Omega_M = %.4f'%(Omega_m) # read the positions of all the particles pos = readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/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])) if do_RSD: print 'moving particles to redshift-space' # read the velocities of all the particles vel = readsnap.read_block(snapshot_fname,"VEL ",parttype=-1) #km/s RSL.pos_redshift_space(pos,vel,BoxSize,Hubble,redshift,axis); del vel # read the masses of all the particles if not(hydro): Ntotal = np.sum(Nall,dtype=np.int64) #compute the number of particles 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 = readsnap.read_block(snapshot_fname,"MASS",parttype=-1)*1e10 #Msun/h print '%.3e < M [Msun/h] < %.3e'%(np.min(M),np.max(M)) print 'Omega_M = %.4f\n'%(np.sum(M,dtype=np.float64)/rho_crit/BoxSize**3) # compute the mean mass per grid cell mean_M = np.sum(M,dtype=np.float64)/dims**3 # compute the mass within each grid cell delta = np.zeros(dims**3,dtype=np.float32) CIC.CIC_serial(pos,dims,BoxSize,delta,M); del pos print '%.6e should be equal to \n%.6e\n'\ %(np.sum(M,dtype=np.float64),np.sum(delta,dtype=np.float64)); del M # compute the density constrast within each grid cell delta/=mean_M; delta-=1.0 print '%.3e < delta < %.3e\n'%(np.min(delta),np.max(delta)) # compute the P(k) Pk = PSL.power_spectrum_given_delta(delta,dims,BoxSize) # write P(k) to output file np.savetxt(f_out,np.transpose([Pk[0],Pk[1]]))
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) #h*km/s/Mpc h=head.hubble #find the total number of particles in the simulation Ntotal=np.sum(Nall,dtype=np.uint64) print 'Total number of particles in the simulation =',Ntotal ################################## HI ########################################### #sort the pos and vel array ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 #normalized print 'sorting the POS array...' pos_unsort=readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/1e3 #Mpc/h pos=np.empty((Ntotal,3),dtype=np.float32); pos[ID_unsort]=pos_unsort del pos_unsort,ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned if method=='Dave': [IDs,M_HI]=HIL.Dave_HI_assignment(snapshot_fname,HI_frac,fac) elif method=='method_1': [IDs,M_HI]=HIL.method_1_HI_assignment(snapshot_fname,HI_frac,Omega_HI_ref) elif method=='Barnes': [IDs,M_HI]=HIL.Barnes_Haehnelt(snapshot_fname,groups_fname, groups_number,long_ids_flag,SFR_flag) elif method=='Paco': [IDs,M_HI]=HIL.Paco_HI_assignment(snapshot_fname,groups_fname,
def hod(snapshot_fname, groups_fname, groups_number, min_mass, max_mass, fiducial_density, M1, alpha, mass_criteria, verbose=False): thres = 1e-3 #controls the max relative error to accept a galaxy density #read the header and obtain the boxsize head = readsnap.snapshot_header(snapshot_fname) BoxSize = head.boxsize #BoxSize in kpc/h #read positions and IDs of DM particles: sort the IDs array DM_pos = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) #kpc/h DM_ids = readsnap.read_block(snapshot_fname, "ID ", parttype=-1) - 1 sorted_ids = DM_ids.argsort(axis=0) #the particle whose ID is N is located in the position sorted_ids[N] #i.e. DM_ids[sorted_ids[N]]=N #the position of the particle whose ID is N would be: #DM_pos[sorted_ids[N]] #read the IDs of the particles belonging to the CDM halos halos_ID = readsubf.subf_ids(groups_fname, groups_number, 0, 0, long_ids=True, read_all=True) IDs = halos_ID.SubIDs - 1 del halos_ID #read CDM halos information halos = readsubf.subfind_catalog(groups_fname, groups_number, group_veldisp=True, masstab=True, long_ids=True, swap=False) if mass_criteria == 't200': halos_mass = halos.group_m_tophat200 * 1e10 #masses in Msun/h halos_radius = halos.group_r_tophat200 #radius in kpc/h elif mass_criteria == 'm200': halos_mass = halos.group_m_mean200 * 1e10 #masses in Msun/h halos_radius = halos.group_r_mean200 #radius in kpc/h elif mass_criteria == 'c200': halos_mass = halos.group_m_crit200 * 1e10 #masses in Msun/h halos_radius = halos.group_r_crit200 #radius in kpc/h else: print('bad mass_criteria') sys.exit() halos_pos = halos.group_pos #positions in kpc/h halos_len = halos.group_len halos_offset = halos.group_offset halos_indexes = np.where((halos_mass > min_mass) & (halos_mass < max_mass))[0] del halos if verbose: print(' ') print('total halos found=', halos_pos.shape[0]) print('halos number density=', len(halos_pos) / (BoxSize * 1e-3)**3) #keep only the halos in the given mass range halo_mass = halos_mass[halos_indexes] halo_pos = halos_pos[halos_indexes] halo_radius = halos_radius[halos_indexes] halo_len = halos_len[halos_indexes] halo_offset = halos_offset[halos_indexes] del halos_indexes ##### COMPUTE Mmin GIVEN M1 & alpha ##### i = 0 max_iterations = 20 #maximum number of iterations Mmin1 = min_mass Mmin2 = max_mass while (i < max_iterations): Mmin = 0.5 * (Mmin1 + Mmin2) #estimation of the HOD parameter Mmin total_galaxies = 0 inside = np.where(halo_mass > Mmin)[0] #take all galaxies with M>Mmin mass = halo_mass[ inside] #only halos with M>Mmin have central/satellites total_galaxies = mass.shape[0] + np.sum((mass / M1)**alpha) mean_density = total_galaxies * 1.0 / (BoxSize * 1e-3)**3 #galaxies/(Mpc/h)^3 if (np.absolute( (mean_density - fiducial_density) / fiducial_density) < thres): i = max_iterations elif (mean_density > fiducial_density): Mmin1 = Mmin else: Mmin2 = Mmin i += 1 if verbose: print(' ') print('Mmin=', Mmin) print('average number of galaxies=', total_galaxies) print('average galaxy density=', mean_density) ######################################### #just halos with M>Mmin; the rest do not host central/satellite galaxies inside = np.where(halo_mass > Mmin)[0] halo_mass = halo_mass[inside] halo_pos = halo_pos[inside] halo_radius = halo_radius[inside] halo_len = halo_len[inside] halo_offset = halo_offset[inside] del inside #compute number of satellites in each halo using the Poisson distribution N_mean_sat = (halo_mass / M1)**alpha #mean number of satellites N_sat = np.empty(len(N_mean_sat), dtype=np.int32) for i in range(len(N_sat)): N_sat[i] = np.random.poisson(N_mean_sat[i]) N_tot = np.sum(N_sat) + len( halo_mass) #total number of galaxies in the catalogue if verbose: print(' ') print(np.min(halo_mass), '< M_halo <', np.max(halo_mass)) print('total number of galaxies=', N_tot) print('galaxy number density=', N_tot / (BoxSize * 1e-3)**3) #put satellites following the distribution of dark matter in groups if verbose: print(' ') print('Creating mock catalogue ...', ) pos_galaxies = np.empty((N_tot, 3), dtype=np.float32) #index: variable that go through halos (may be several galaxies in a halo) #i: variable that go through all (central/satellites) galaxies #count: find number of galaxies that lie beyond its host halo virial radius index = 0 count = 0 i = 0 while (index < halo_mass.shape[0]): position = halo_pos[index] #position of the DM halo radius = halo_radius[index] #radius of the DM halo #save the position of the central galaxy pos_galaxies[i] = position i += 1 #if halo contains satellites, save their positions Nsat = N_sat[index] if Nsat > 0: offset = halo_offset[index] length = halo_len[index] idss = sorted_ids[IDs[offset:offset + length]] #compute the distances to the halo center keeping those with R<Rvir pos = DM_pos[ idss] #positions of the particles belonging to the halo posc = pos - position #this is to populate correctly halos closer to box boundaries if np.any((position + radius > BoxSize) + (position - radius < 0.0)): inside = np.where(posc[:, 0] > BoxSize / 2.0)[0] posc[inside, 0] -= BoxSize inside = np.where(posc[:, 0] < -BoxSize / 2.0)[0] posc[inside, 0] += BoxSize inside = np.where(posc[:, 1] > BoxSize / 2.0)[0] posc[inside, 1] -= BoxSize inside = np.where(posc[:, 1] < -BoxSize / 2.0)[0] posc[inside, 1] += BoxSize inside = np.where(posc[:, 2] > BoxSize / 2.0)[0] posc[inside, 2] -= BoxSize inside = np.where(posc[:, 2] < -BoxSize / 2.0)[0] posc[inside, 2] += BoxSize radii = np.sqrt(posc[:, 0]**2 + posc[:, 1]**2 + posc[:, 2]**2) inside = np.where(radii < radius)[0] selected = random.sample(inside, Nsat) pos = pos[selected] #aditional, not esential check. Can be comment out posc = pos - position if np.any((posc > BoxSize / 2.0) + (posc < -BoxSize / 2.0)): inside = np.where(posc[:, 0] > BoxSize / 2.0)[0] posc[inside, 0] -= BoxSize inside = np.where(posc[:, 0] < -BoxSize / 2.0)[0] posc[inside, 0] += BoxSize inside = np.where(posc[:, 1] > BoxSize / 2.0)[0] posc[inside, 1] -= BoxSize inside = np.where(posc[:, 1] < -BoxSize / 2.0)[0] posc[inside, 1] += BoxSize inside = np.where(posc[:, 2] > BoxSize / 2.0)[0] posc[inside, 2] -= BoxSize inside = np.where(posc[:, 2] < -BoxSize / 2.0)[0] posc[inside, 2] += BoxSize r_max = np.max( np.sqrt(posc[:, 0]**2 + posc[:, 1]**2 + posc[:, 2]**2)) if r_max > radius: #check no particles beyond Rv selected print(position) print(radius) print(pos) count += 1 for j in range(Nsat): pos_galaxies[i] = pos[j] i += 1 index += 1 if verbose: print('done') #some final checks if i != N_tot: print('some galaxies missing:') print('register', i, 'galaxies out of', N_tot) if count > 0: print('error:', count, 'particles beyond the virial radius selected') return pos_galaxies
############################################################################### #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) #h*km/s/Mpc h = head.hubble #read the positions and SPH smoothing lengths of the gas particles pos = readsnap.read_block(snapshot_fname, "POS ", parttype=0) / 1e3 #Mpc/h radii = readsnap.read_block(snapshot_fname, "HSML", parttype=0) / 1e3 #Mpc/h """ print len(np.where(radii<(BoxSize/1024.0))[0])*1.0/len(radii) bins_histo=np.logspace(np.log10(np.min(radii)),np.log10(np.max(radii)),101) middle_bin=0.5*(bins_histo[1:]+bins_histo[:-1]) H=np.histogram(radii,bins=bins_histo)[0]*1.0/len(radii) print np.sum(H,dtype=np.float64) f=open('borrar.dat','w') for i in range(100): f.write(str(middle_bin[i])+' '+str(H[i])+'\n') f.close() """ #compute the density in the grid cells delta = np.zeros(dims**3, dtype=np.float32)
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 #define the array containing the deltas delta = np.zeros(dims3,dtype=np.float32) #read the positions and masses of the CDM particles pos = readsnap.read_block(snapshot_fname,"POS ",parttype=1)/1e3 #Mpc/h mass = readsnap.read_block(snapshot_fname,"MASS",parttype=1)*1e10 #Msun/h if do_RSD: vel = readsnap.read_block(snapshot_fname,"VEL ",parttype=1) #km/s print 'Omega_CDM = %.4f'%(np.sum(mass,dtype=np.float64)/BoxSize**3/rho_crit) #if there are neutrinos read their positions and masses if Nall[2]>0: pos_nu = readsnap.read_block(snapshot_fname,"POS ",parttype=2)/1e3 #Mpc/h mass_nu = readsnap.read_block(snapshot_fname,"MASS",parttype=2)*1e10 #Msun/h print 'Omega_NU = %.4f'\ %(np.sum(mass_nu,dtype=np.float64)/BoxSize**3/rho_crit) pos = np.vstack([pos,pos_nu]); del pos_nu mass = np.hstack([mass,mass_nu]); del mass_nu if do_RSD: vel_nu = readsnap.read_block(snapshot_fname,"VEL ",parttype=2) #km/s
z_max = nu0 / nu_max - 1.0 print 'Channel redshift interval: %1.4f < z < %1.4f' % (z_min, z_max) print 'Channel frequency [%1.3f - %1.3f] MHz' % (nu_max, nu_min) delta_r = cl.comoving_distance(z_max, Omega_m, Omega_l) - r print 'delta_r channel = %2.2f Mpc/h' % delta_r grid_res = (ang_res / 60.0) * (pi / 180.0) * r #grid resolution print '\nSpatial resolution = %2.3f Mpc/h' % grid_res #find the total number of particles in the simulation Ntotal = np.sum(Nall, dtype=np.uint64) print '\nTotal number of particles in the simulation:', Ntotal #sort the pos and vel array ID_unsort = readsnap.read_block(snapshot_fname, "ID ", parttype=-1) - 1 #normalized pos_unsort = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) / 1e3 #Mpc/h vel_unsort = readsnap.read_block(snapshot_fname, "VEL ", parttype=-1) #km/s pos = np.empty((Ntotal, 3), dtype=np.float32) pos[ID_unsort] = pos_unsort vel = np.empty((Ntotal, 3), dtype=np.float32) vel[ID_unsort] = vel_unsort del pos_unsort, vel_unsort, ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned if method == 'Dave': [IDs, M_HI] = HIL.Dave_HI_assignment(snapshot_fname, HI_frac, fac) elif method == 'method_1': [IDs, M_HI] = HIL.method_1_HI_assignment(snapshot_fname, HI_frac, Omega_HI_ref)
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) #h*km/s/Mpc h = head.hubble #find the total number of particles in the simulation Ntotal = np.sum(Nall, dtype=np.uint64) print 'Total number of particles in the simulation =', Ntotal ################################## HI ########################################### #sort the pos and vel array ID_unsort = readsnap.read_block(snapshot_fname, "ID ", parttype=-1) - 1 #normalized print 'sorting the POS array...' pos_unsort = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) / 1e3 #Mpc/h pos = np.empty((Ntotal, 3), dtype=np.float32) pos[ID_unsort] = pos_unsort del pos_unsort, ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned if method == 'Dave': [IDs, M_HI] = HIL.Dave_HI_assignment(snapshot_fname, HI_frac, fac) elif method == 'method_1': [IDs, M_HI] = HIL.method_1_HI_assignment(snapshot_fname, HI_frac, Omega_HI_ref) elif method == 'Barnes': [IDs, M_HI] = HIL.Barnes_Haehnelt(snapshot_fname, groups_fname,
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) #define the delta array and the mean_mass variable delta = np.zeros(dims3,dtype=np.float32) mean_mass = 0.0 #Msun/h #make a loop over all particle types and sum their masses in the grid for ptype in particle_type: #read particle positions pos = readsnap.read_block(snapshot_fname,"POS ", parttype=ptype)/1e3 #Mpc/h #displace 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 #read particle masses mass = readsnap.read_block(snapshot_fname,"MASS", parttype=ptype)*1e10 #Msun/h print 'Number of '+pname[ptype]+' particles =',len(pos) print '%.4f < X < %.4f'%(np.min(pos[:,0]), np.max(pos[:,0])) print '%.4f < Y < %.4f'%(np.min(pos[:,1]), np.max(pos[:,1]))
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) #h*km/s/Mpc h=head.hubble #compute the values of Omega_CDM and Omega_B Omega_cdm=Nall[1]*Masses[1]/BoxSize**3/rho_crit Omega_b=Omega_m-Omega_cdm print '\nOmega_CDM = %.3f\nOmega_B = %0.3f\nOmega_M = %.3f\n'\ %(Omega_cdm,Omega_b,Omega_m) #read the positions of all the particles pos=readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/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 all the particles vel=readsnap.read_block(snapshot_fname,"VEL ",parttype=-1) #kms if do_RSD: print 'moving particles to redshift-space' RSD(pos[:,axis],vel[:,axis],Hubble,redshift) #read the masses of all the particles M=readsnap.read_block(snapshot_fname,"MASS",parttype=-1)*1e10 #Msun/h print '%.3e < M [Msun/h] < %.3e'%(np.min(M),np.max(M)) print 'Omega_m = %.3f\n'%(np.sum(M,dtype=np.float64)/rho_crit/BoxSize**3)
Omega_l=head.omega_l redshift=head.redshift Hubble=100.0*np.sqrt(Omega_m*(1.0+redshift)**3+Omega_l) #h*km/s/Mpc h=head.hubble #split the particle IDs among CDM, gas and stars and also among enviroment indexes=HIL.particle_indexes(snapshot_fname,groups_fname,groups_number, long_ids_flag,SFR_flag,mass_interval,min_mass, max_mass) #find the total number of particles in the simulation Ntotal=np.sum(Nall,dtype=np.uint64) print 'Total number of particles in the simulation =',Ntotal #sort the pos array ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 #normalized pos_unsort=readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/1e3 #Mpc/h pos=np.empty((Ntotal,3),dtype=np.float32); pos[ID_unsort]=pos_unsort #find the IDs of the gas particles residing in filaments IDs=indexes.gas_filaments #find the IDs and HI masses of the particles to which HI has been assigned #note that these IDs_g correspond to all the particles to which HI has been #assigned if method=='Bagla' or method=='Paco': #sort the HI/H array: only use gas particles ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=0)-1#normalized nH0_unsort=readsnap.read_block(snapshot_fname,"NH ",parttype=0)*fac #HI/H nH0=np.zeros(Ntotal,dtype=np.float32); nH0[ID_unsort]=nH0_unsort
#################################### INPUT #################################### snapshot_fname = '../ics' bins = 100 #number of bins for the distribution # parameters for the FD distribution Mnu = 0.6 #eV h_planck = 6.582e-16 #eV*s kB = 8.617e-5 #eV/K c = 3e5 #km/s Tnu = 1.95 #K ############################################################################### ########## fraction from simulation ########### # read snapshot redshift and neutrino velocities z = readsnap.snapshot_header(snapshot_fname).redshift vel = readsnap.read_block(snapshot_fname,"VEL ",parttype=2) #km/s # compute velocity modulus V = np.sqrt(vel[:,0]**2 + vel[:,1]**2 + vel[:,2]**2); del vel # define the velocity intervals, their mean value and their widths vel_min, vel_max = np.min(V),np.max(V) if vel_min==0.0: vel_min = 1e-3 vel_intervals = np.logspace(np.log10(vel_min),np.log10(vel_max),bins+1) dV = vel_intervals[1:] - vel_intervals[:-1] #km/s V_mean = 0.5*(vel_intervals[1:] + vel_intervals[:-1]) #km/s # compute the franction of neutrinos within each velocity bin hist = (np.histogram(V,bins=vel_intervals)[0])*1.0/len(V) ###############################################
from colossus.halo import profile_nfw from colossus.halo import concentration # Setting cosmology for concentrations pdict = {'flat': True, 'H0': params.h0true, 'Om0': params.omega0, 'Ob0': params.omegabaryon,\ 'sigma8': cosmology.sigma8, 'ns': params.ns} colossus.addCosmology('myCosmo', pdict) colossus.setCosmology('myCosmo') # Load Catalog cat = catalog(params.pincatfile.format(0.0)) rhoc = cosmology.lcdm.critical_density(0.0).to("M_sun/Mpc^3").value rDelta = (3 * cat.Mass / 4 / np.pi / 200 / rhoc)**(1.0 / 3) # Getting particle positions and particle mass pos = rs.read_block( params.pintlessfile.replace("t_snapshot", r"{0:5.4f}").format(0.0), "POS ") mp = rs.snapshot_header( params.pintlessfile.replace("t_snapshot", r"{0:5.4f}").format(0.0)).massarr[1] * 1e10 # Getting the Index of the i-th passive object in catalog idx = np.argsort(cat.Mass)[-1] # Getting the first and last icdx of the particles inside the most massive halo idxp1 = np.sum(cat.Npart[:idx]) idxp2 = idxp1 + cat.Npart[idx] plt.scatter(pos[idxp1:idxp2][:, 0], pos[idxp1:idxp2][:, 1], s=0.1) plt.show() plt.scatter(pos[idxp1:idxp2][:, 0], pos[idxp1:idxp2][:, 2], s=0.1)
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) #h*km/s/Mpc h=head.hubble #find the total number of particles in the simulation Ntotal=np.sum(Nall,dtype=np.uint64) print 'Total number of particles in the simulation =',Ntotal ################################## HI ########################################### #sort the pos and vel array ID_unsort=readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 #normalized print 'sorting the POS array...' pos_unsort=readsnap.read_block(snapshot_fname,"POS ",parttype=-1)/1e3 #Mpc/h pos=np.empty((Ntotal,3),dtype=np.float32); pos[ID_unsort]=pos_unsort; del pos_unsort del ID_unsort #find the IDs and HI masses of the particles to which HI has been assigned if method=='Dave': [IDs,M_HI]=HIL.Dave_HI_assignment(snapshot_fname,HI_frac,fac) elif method=='method_1': [IDs,M_HI]=HIL.method_1_HI_assignment(snapshot_fname,HI_frac,Omega_HI_ref) elif method=='Barnes': [IDs,M_HI]=HIL.Barnes_Haehnelt(snapshot_fname,groups_fname, groups_number,long_ids_flag,SFR_flag) elif method=='Paco': [IDs,M_HI]=HIL.Paco_HI_assignment(snapshot_fname,groups_fname,
def generate_lens_map(lenses, cpunum, LC, Halo_HF_ID, Halo_ID, Halo_z, Rvir, snapnum, snapfile, h, scale, Ncells, HQ_dir, sim, sim_phy, sim_name, HaloPosBox, HaloVel, cosmo, results_per_cpu): """ Input: ll: halo array indexing LC: Light-cone dictionary Halo_ID: ID of Halo Halo_z: redshift of Halo Rvir: virial radius in [Mpc] previous_snapnum: snapnum Output: """ print('Process %s started' % mp.current_process().name) first_lens = lenses[0] previous_snapnum = snapnum[first_lens] memtrack = 0 file = open('F6_test_'+str(mp.current_process().name)+'.txt','w') lenslistinit() # Run through lenses for ll in range(first_lens, lenses[-1]): zs, Src_ID, SrcPosSky = source_selection(LC['Src_ID'], LC['Src_z'], LC['SrcPosSky'], Halo_ID[ll]) zl = Halo_z[ll] Lbox = Rvir[ll]*0.3*u.Mpc FOV = Lbox.to_value('Mpc') # converting box size and pixels size from ang. diam. dist. to arcsec FOV_arc = (FOV/cf.Da(zl, cosmo)*u.rad).to_value('arcsec') #[arcsec] box size dsx_arc = FOV_arc/Ncells #[arcsec] pixel size # initialize the coordinates of grids (light rays on lens plan) lp1, lp2 = cf.make_r_coor(FOV_arc, Ncells) #[arcsec] # Only load new particle data if lens is at another snapshot if (previous_snapnum != snapnum[ll]) or (ll == first_lens): snap = snapfile % (snapnum[ll], snapnum[ll]) # 0 Gas, 1 DM, 4 Star[Star=+time & Wind=-time], 5 BH DM_pos = readsnap.read_block(snap, 'POS ', parttype=1)*scale #[Mpc] DM_mass = readsnap.read_block(snap, 'MASS', parttype=1)*1e10/h Gas_pos = readsnap.read_block(snap, 'POS ', parttype=0)*scale #[Mpc] Gas_mass = readsnap.read_block(snap, 'MASS', parttype=0)*1e10/h Star_pos = readsnap.read_block(snap, 'POS ', parttype=4)*scale #[Mpc] Star_age = readsnap.read_block(snap, 'AGE ', parttype=4) Star_mass = readsnap.read_block(snap, 'MASS', parttype=4) Star_pos = Star_pos[Star_age >= 0] Star_mass = Star_mass[Star_age >= 0]*1e10/h del Star_age BH_pos = readsnap.read_block(snap, 'POS ', parttype=5)*scale BH_mass = readsnap.read_block(snap, 'MASS', parttype=5)*1e10/h file.write(str(mp.current_process().name) + 'read particles \n') previous_snapnum = snapnum[ll] DM_sigma, xs, ys = projected_surface_density(ll, DM_pos, #[Mpc] DM_mass, HaloPosBox[ll], fov=FOV, #[Mpc] bins=Ncells, smooth=False, smooth_fac=0.5, neighbour_no=32) Gas_sigma, xs, ys = projected_surface_density(ll, Gas_pos, #*a/h, Gas_mass, HaloPosBox[ll], #*a/h, fov=FOV, bins=Ncells, smooth=False, smooth_fac=0.5, neighbour_no=32) Star_sigma, xs, ys = projected_surface_density(ll, Star_pos, #*a/h, Star_mass, HaloPosBox[ll], #*a/h, fov=FOV, bins=Ncells, smooth=False, smooth_fac=0.5, neighbour_no=8) file.write(str(mp.current_process().name) + 'created surfce densities \n') # point sources need to be smoothed by > 1 pixel to avoid artefacts tot_sigma = DM_sigma + Gas_sigma + Star_sigma srclistinit() # Run through Sources check_for_sources = 0 for ss in range(len(Src_ID)): # Calculate critical surface density sigma_cr = sigma_crit(zl, zs[ss], cosmo).to_value('Msun Mpc-2') kappa = tot_sigma/sigma_cr fig = plt.figure() ax = fig.add_subplot(111) kappa = gaussian_filter(kappa, sigma=3) # Calculate Deflection Maps alpha1, alpha2, mu_map, phi, detA, lambda_t = cal_lensing_signals(kappa, FOV_arc, Ncells) file.write(str(ll)+'; '+str(ss)+'; '+str(mp.current_process().name) + ' lensing signals \n') # Calculate Einstein Radii Ncrit, curve_crit, curve_crit_tan, Rein = einstein_radii(lp1, lp2, detA, lambda_t, zl, cosmo, ax, 'med') file.write(str(mp.current_process().name)+' Rein calc \n') # Calculate Time-Delay and Magnification n_imgs, delta_t, mu, theta, beta = timedelay_magnification(mu_map, phi, dsx_arc, Ncells, lp1, lp2, alpha1, alpha2, SrcPosSky[ss], zs[ss], zl, cosmo) file.write(str(mp.current_process().name)+' time delay \n') if n_imgs > 1: file.write(str(mp.current_process().name)+' adding multi source --------------- \n') print('%s, %s, %s' % (str(mp.current_process().name), str(ll), str(ss))) # Tree Branch 2 s_srcID.append(Src_ID[ss]) print('-- zs[ss]', zs) s_zs.append(zs[ss]) s_beta.append(beta) #s_lensplane.append([lp1, lp2]) s_detA.append(detA) s_tancritcurves.append(curve_crit_tan) s_einsteinradius.append(Rein) # Tree Branch 3 s_theta.append(theta) s_deltat.append(delta_t) s_mu.append(mu) check_for_sources = 1 if check_for_sources == 1: # Tree Branch 1 l_HFID.append(Halo_HF_ID[ll]) l_haloID.append(Halo_ID[ll]) l_snapnum.append(int(snapnum[ll])) l_zl.append(Halo_z[ll]) l_haloposbox.append(HaloPosBox[ll]) l_halovel.append(HaloVel[ll]) # Tree Branch 2 l_srcID.append(s_srcID) l_zs.append(s_zs) l_srcbeta.append(s_beta) #l_lensplane.append(s_lensplane) l_detA.append(s_detA) l_tancritcurves.append(s_tancritcurves) l_einsteinradius.append(s_einsteinradius) # Tree Branch 3 l_srctheta.append(s_theta) l_deltat.append(s_deltat) l_mu.append(s_mu) #memuseout = (sys.getsizeof(l_HFID) + sys.getsizeof(l_haloID) + \ # sys.getsizeof(l_snapnum) + sys.getsizeof(l_zl) + \ # sys.getsizeof(l_haloposbox) + sys.getsizeof(l_halovel) + \ # sys.getsizeof(l_srcID) + sys.getsizeof(l_zs) + \ # sys.getsizeof(l_srcbeta) + sys.getsizeof(l_detA) + \ # sys.getsizeof(l_tancritcurves) + sys.getsizeof(l_einsteinradius) + \ # sys.getsizeof(l_srctheta) + sys.getsizeof(l_deltat) + \ # sys.getsizeof(l_mu))/1024**3 #[GB] memusetot = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024**3 #[GB] print('::::::::::::: Tot. Memory Size [GB]: ', memusetot) if memusetot > 5: ########## Save to File ######## print('save file because it is too big') tree = plant_Tree() #tree = grow_Tree() # Tree Branches of Node 1 : Lenses tree['Halo_ID'] = l_haloID tree['HF_ID'] = l_HFID tree['snapnum'] = l_snapnum tree['zl'] = l_zl tree['HaloPosBox'] = l_haloposbox tree['HaloVel'] = l_halovel for sid in range(len(l_haloID)): # Tree Branches of Node 2 : Sources tree['Sources']['Src_ID'][sid] = l_srcID[sid] tree['Sources']['zs'][sid] = l_zs[sid] tree['Sources']['beta'][sid] = l_srcbeta[sid] #tree['Sources']['LP'][sid] = l_lensplane[sid] tree['Sources']['detA'][sid] = l_detA[sid] tree['Sources']['TCC'][sid] = l_tancritcurves[sid] tree['Sources']['Rein'][sid] = l_einsteinradius[sid] for imgs in range(len(l_srcID[sid])): # Tree Branches of Node 3 : Multiple Images tree['Sources']['theta'][sid][imgs] = l_srctheta[sid][imgs] tree['Sources']['delta_t'][sid][imgs] = l_deltat[sid][imgs] tree['Sources']['mu'][sid][imgs] = l_mu[sid][imgs] lm_dir = HQ_dir+'LensingMap/'+sim_phy[sim]+'/'+sim_name[sim]+'/' ensure_dir(lm_dir) filename = lm_dir+'LM_'+mp.current_process().name+'_' + \ str(memtrack)+'.pickle' filed = open(filename, 'wb') pickle.dump(tree, filed) filed.close() plt.close(fig) memtrack += 1 lenslistinit() srclistinit() ########## Save to File ######## tree = plant_Tree() #tree = grow_Tree() # Tree Branches of Node 1 : Lenses tree['Halo_ID'] = l_haloID tree['HF_ID'] = l_HFID tree['snapnum'] = l_snapnum tree['zl'] = l_zl tree['HaloPosBox'] = l_haloposbox tree['HaloVel'] = l_halovel for sid in range(len(l_haloID)): # Tree Branches of Node 2 : Sources tree['Sources']['Src_ID'][sid] = l_srcID[sid] tree['Sources']['zs'][sid] = l_zs[sid] tree['Sources']['beta'][sid] = l_srcbeta[sid] #tree['Sources']['LP'][sid] = l_lensplane[sid] tree['Sources']['detA'][sid] = l_detA[sid] tree['Sources']['TCC'][sid] = l_tancritcurves[sid] tree['Sources']['Rein'][sid] = l_einsteinradius[sid] for imgs in range(len(l_srcID[sid])): # Tree Branches of Node 3 : Multiple Images tree['Sources']['theta'][sid][imgs] = l_srctheta[sid][imgs] tree['Sources']['delta_t'][sid][imgs] = l_deltat[sid][imgs] tree['Sources']['mu'][sid][imgs] = l_mu[sid][imgs] file.close() lm_dir = HQ_dir+'LensingMap/'+sim_phy[sim]+'/'+sim_name[sim]+'/' ensure_dir(lm_dir) filename = lm_dir+'LM_'+mp.current_process().name+'_' + \ str(memtrack)+'.pickle' filed = open(filename, 'wb') pickle.dump(tree, filed) filed.close() plt.close(fig)
DR_action='compute' #'compute' or 'read' (from DR_name file) #### wp FILE #### wp_file='w_p_21.dat' #### OUTPUT #### results_file='500Mpc_512_0.6_mean200.dat' ###################################################### M1_array=np.linspace(M1_min, M1_max, M1_bins) alpha_array=np.linspace(alpha_min, alpha_max, alpha_bins) if myrank==0: #read positions and IDs of DM particles: sort the IDs array DM_pos=readsnap.read_block(snapshot_fname,"POS ",parttype=-1) DM_ids=readsnap.read_block(snapshot_fname,"ID ",parttype=-1) print len(DM_ids),np.min(DM_ids),np.max(DM_ids) sorted_ids=DM_ids.argsort(axis=0) del DM_ids #the particle whose ID is N is located in the position sorted_ids[N] #i.e. DM_ids[sorted_ids[N]]=N #the position of the particle whose ID is N would be: #DM_pos[sorted_ids[N]] #read the IDs of the particles belonging to the CDM halos halos_ID=readsubf.subf_ids(groups_fname,groups_number,0,0, long_ids=True,read_all=True) IDs=halos_ID.SubIDs del halos_ID
#read subhalos positions/masses subhalos_mass = halos.sub_mass*1e10 #masses in Msun/h subhalos_pos = halos.sub_pos/1e3 #positions in Mpc/h if obj == 'halos': halos_indexes = np.where((halos_mass>min_mass) & \ (halos_mass<max_mass))[0] pos_g = halos_pos[halos_indexes] else: halos_indexes = np.where((subhalos_mass>min_mass) & \ (subhalos_mass<max_mass))[0] pos_g = halos_pos[halos_indexes] elif obj == 'DM': #read snapshot file PAR_pos = readsnap.read_block(snapshot_fname,"POS ",parttype=1)/1e3#Mpc/h IDs = np.arange(len(PAR_pos)); IDs=random.sample(IDs,N_par) pos_g = PAR_pos[IDs]; del PAR_pos,IDs elif obj == 'data': #read Pinocchio halos information data = np.loadtxt(data_file,comments='#') Pin_pos = data[:,5:8]; Pin_mass = data[:,1]; Pin_vel = data[:,8:11] Pin_pos = Pin_pos.astype(np.float32); Pin_mass = Pin_mass.astype(np.float32) Pin_vel = Pin_vel.astype(np.float32) halos_indexes = np.where((Pin_mass>min_mass) & \ (Pin_mass<max_mass))[0] pos_g = Pin_pos[halos_indexes] if do_RSD: vel_g = Pin_vel[halos_indexes]
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 fout = 'CF_CDM_z=%.3f.txt' % redshift # read the positions and masses of the CDM particles pos = readsnap.read_block(snapshot_fname, "POS ", parttype=1) / 1e3 #Mpc/h # compute delta_CDM delta = np.zeros((dims, dims, dims), dtype=np.float32) MASL.MA(pos, delta, BoxSize, MAS) print '%.6e should be equal to\n%.6e'\ %(np.sum(delta,dtype=np.float64),len(pos)) delta /= np.mean(delta, dtype=np.float64) delta -= 1.0 #compute the correlation function CF = PKL.Xi(delta, BoxSize, MAS, threads=8) #save results to file np.savetxt(fout, np.transpose([CF.r3D, CF.xi]))
def dyn_vs_lensing_mass(cpunum, LC, lm_file, snapfile, h, scale, HQ_dir, sim, sim_phy, sim_name, hfname, cosmo, results_per_cpu): """ Input: ll: halo array indexing LC: Light-cone dictionary Halo_ID: ID of Halo Halo_z: redshift of Halo Rvir: virial radius in [Mpc] previous_snapnum: snapnum Output: """ LM = pickle.load(open(lm_file, 'rb')) #, encoding="utf8") logging.info('Process %s started. Nr. of Halos: %s' % (mp.current_process().name, len(LM['Halo_ID']))) results = [] previous_snapnum = -1 # Run through lenses for ll in range(len(LM['Halo_ID'])): # Load Lens properties #HaloHFID= LM['HF_ID'][ll] HaloHFID = int(LM['Rockstar_ID'][ll]) HaloPosBox = LM['HaloPosBox'][ll] HaloVel = LM['HaloVel'][ll] snapnum = LM['snapnum'][ll] zl = LM['zl'][ll] # Only load new particle data if lens is at another snapshot if (previous_snapnum != snapnum): # Load Halo Properties rks_file = '/cosma5/data/dp004/dc-beck3/rockstar/'+sim_phy[sim]+ \ sim_name[sim]+'/halos_' + str(snapnum)+'.dat' df = pd.read_csv( rks_file, sep='\s+', skiprows=16, usecols=[0, 4, 5, 30, 31, 32, 33, 34, 35, 36, 37, 38, 47], names=[ 'ID', 'Vrms', 'Rvir', 'A[x]', 'A[y]', 'A[z]', 'B[x]', 'B[y]', 'B[z]', 'C[x]', 'C[y]', 'C[z]', 'Halfmass_Radius' ]) # Load Particle Properties #s = read_hdf5.snapshot(snapnum, snapfile) # 0 Gas, 1 DM, 4 Star[Star=+time & Wind=-time], 5 BH # Have to load all particles :-( -> takes too long #s.read(["Velocities", "Coordinates", "AGE"], parttype=-1) #Star_pos = s.data['Velocities']['stars']*scale snap = snapfile % (snapnum, snapnum) Star_age = readsnap.read_block(snap, 'AGE ', parttype=4) Star_pos = readsnap.read_block(snap, 'POS ', parttype=4) * scale #[Mpc] Star_vel = readsnap.read_block(snap, 'VEL ', parttype=4) Star_mass = readsnap.read_block(snap, 'MASS', parttype=4) * 1e10 / h Star_pos = Star_pos[Star_age >= 0] Star_vel = Star_vel[Star_age >= 0] Star_mass = Star_mass[Star_age >= 0] del Star_age previous_snapnum = snapnum # Load Halo Properties indx = df['ID'][df['ID'] == HaloHFID].index[0] Vrms = df['Vrms'][indx] * (u.km / u.s) #[km/s] Rvir = df['Rvir'][indx] * u.kpc Rhalfmass = df['Halfmass_Radius'][indx] * u.kpc epva = pd.concat([df['A[x]'], df['A[y]'], df['A[z]']], axis=1).loc[[indx]].values epvb = pd.concat([df['B[x]'], df['B[y]'], df['B[z]']], axis=1).loc[[indx]].values epvc = pd.concat([df['C[x]'], df['C[y]'], df['C[z]']], axis=1).loc[[indx]].values # Stellar half mass radius Rshm = cf.call_stellar_halfmass( Star_pos[:, 0], Star_pos[:, 1], Star_pos[:, 2], HaloPosBox[0], HaloPosBox[1], HaloPosBox[2], Star_mass, Rvir.to_value('Mpc')) * u.Mpc #print('Rshm', Rshm) Star_indx = check_in_sphere(HaloPosBox, Star_pos, Rshm.to_value('kpc')) if len(Star_indx[0]) > 50: Mdyn = mass_dynamical(Rshm, Star_vel[Star_indx], HaloPosBox, HaloVel, epva, epvb, epvc) print('Mdyn', Mdyn) if Mdyn == .0: continue # Run through sources for ss in range(len(LM['Sources']['Src_ID'][ll])): zs = LM['Sources']['zs'][ll][ss] Rein = LM['Sources']['Rein'][ll][ss] * u.kpc Mlens = mass_lensing(Rein, zl, zs, cosmo) #Mdyn = (Vrms.to('m/s')**2*Rvir.to('m')/ \ # const.G.to('m3/(kg*s2)')).to_value('M_sun') results.append([ LM['Halo_ID'][ll], LM['Sources']['Src_ID'][ll][ss], Mdyn, Mlens ]) results_per_cpu[cpunum] = results
# 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 # read particle positions and masses pos = readsnap.read_block(snapshot_fname, "POS ", parttype=ptype) / 1e3 #Mpc/h mass = readsnap.read_block(snapshot_fname, "MASS", parttype=ptype) * 1e10 #Msun/h # 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 # some verbose 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' % (np.min(pos[:, 2]), np.max(pos[:, 2])) print 'Omega_ptype = %.4f' % (np.sum(mass, dtype=np.float64) / BoxSize**3 / rho_crit)
def hod(snapshot_fname,groups_fname,groups_number,min_mass,max_mass, fiducial_density,M1,alpha,mass_criteria,verbose=False): thres=1e-3 #controls the max relative error to accept a galaxy density #read the header and obtain the boxsize head=readsnap.snapshot_header(snapshot_fname) BoxSize=head.boxsize #BoxSize in kpc/h #read positions and IDs of DM particles: sort the IDs array DM_pos=readsnap.read_block(snapshot_fname,"POS ",parttype=-1) #kpc/h DM_ids=readsnap.read_block(snapshot_fname,"ID ",parttype=-1)-1 sorted_ids=DM_ids.argsort(axis=0) #the particle whose ID is N is located in the position sorted_ids[N] #i.e. DM_ids[sorted_ids[N]]=N #the position of the particle whose ID is N would be: #DM_pos[sorted_ids[N]] #read the IDs of the particles belonging to the CDM halos halos_ID=readsubf.subf_ids(groups_fname,groups_number,0,0, long_ids=True,read_all=True) IDs=halos_ID.SubIDs-1 del halos_ID #read CDM halos information halos=readsubf.subfind_catalog(groups_fname,groups_number, group_veldisp=True,masstab=True, long_ids=True,swap=False) if mass_criteria=='t200': halos_mass=halos.group_m_tophat200*1e10 #masses in Msun/h halos_radius=halos.group_r_tophat200 #radius in kpc/h elif mass_criteria=='m200': halos_mass=halos.group_m_mean200*1e10 #masses in Msun/h halos_radius=halos.group_r_mean200 #radius in kpc/h elif mass_criteria=='c200': halos_mass=halos.group_m_crit200*1e10 #masses in Msun/h halos_radius=halos.group_r_crit200 #radius in kpc/h else: print 'bad mass_criteria' sys.exit() halos_pos=halos.group_pos #positions in kpc/h halos_len=halos.group_len halos_offset=halos.group_offset halos_indexes=np.where((halos_mass>min_mass) & (halos_mass<max_mass))[0] del halos if verbose: print ' ' print 'total halos found=',halos_pos.shape[0] print 'halos number density=',len(halos_pos)/(BoxSize*1e-3)**3 #keep only the halos in the given mass range halo_mass=halos_mass[halos_indexes] halo_pos=halos_pos[halos_indexes] halo_radius=halos_radius[halos_indexes] halo_len=halos_len[halos_indexes] halo_offset=halos_offset[halos_indexes] del halos_indexes ##### COMPUTE Mmin GIVEN M1 & alpha ##### i=0; max_iterations=20 #maximum number of iterations Mmin1=min_mass; Mmin2=max_mass while (i<max_iterations): Mmin=0.5*(Mmin1+Mmin2) #estimation of the HOD parameter Mmin total_galaxies=0 inside=np.where(halo_mass>Mmin)[0] #take all galaxies with M>Mmin mass=halo_mass[inside] #only halos with M>Mmin have central/satellites total_galaxies=mass.shape[0]+np.sum((mass/M1)**alpha) mean_density=total_galaxies*1.0/(BoxSize*1e-3)**3 #galaxies/(Mpc/h)^3 if (np.absolute((mean_density-fiducial_density)/fiducial_density)<thres): i=max_iterations elif (mean_density>fiducial_density): Mmin1=Mmin else: Mmin2=Mmin i+=1 if verbose: print ' ' print 'Mmin=',Mmin print 'average number of galaxies=',total_galaxies print 'average galaxy density=',mean_density ######################################### #just halos with M>Mmin; the rest do not host central/satellite galaxies inside=np.where(halo_mass>Mmin)[0] halo_mass=halo_mass[inside] halo_pos=halo_pos[inside] halo_radius=halo_radius[inside] halo_len=halo_len[inside] halo_offset=halo_offset[inside] del inside #compute number of satellites in each halo using the Poisson distribution N_mean_sat=(halo_mass/M1)**alpha #mean number of satellites N_sat=np.empty(len(N_mean_sat),dtype=np.int32) for i in range(len(N_sat)): N_sat[i]=np.random.poisson(N_mean_sat[i]) N_tot=np.sum(N_sat)+len(halo_mass) #total number of galaxies in the catalogue if verbose: print ' ' print np.min(halo_mass),'< M_halo <',np.max(halo_mass) print 'total number of galaxies=',N_tot print 'galaxy number density=',N_tot/(BoxSize*1e-3)**3 #put satellites following the distribution of dark matter in groups if verbose: print ' ' print 'Creating mock catalogue ...', pos_galaxies=np.empty((N_tot,3),dtype=np.float32) #index: variable that go through halos (may be several galaxies in a halo) #i: variable that go through all (central/satellites) galaxies #count: find number of galaxies that lie beyond its host halo virial radius index=0; count=0; i=0 while (index<halo_mass.shape[0]): position=halo_pos[index] #position of the DM halo radius=halo_radius[index] #radius of the DM halo #save the position of the central galaxy pos_galaxies[i]=position; i+=1 #if halo contains satellites, save their positions Nsat=N_sat[index] if Nsat>0: offset=halo_offset[index] length=halo_len[index] idss=sorted_ids[IDs[offset:offset+length]] #compute the distances to the halo center keeping those with R<Rvir pos=DM_pos[idss] #positions of the particles belonging to the halo posc=pos-position #this is to populate correctly halos closer to box boundaries if np.any((position+radius>BoxSize) + (position-radius<0.0)): inside=np.where(posc[:,0]>BoxSize/2.0)[0] posc[inside,0]-=BoxSize inside=np.where(posc[:,0]<-BoxSize/2.0)[0] posc[inside,0]+=BoxSize inside=np.where(posc[:,1]>BoxSize/2.0)[0] posc[inside,1]-=BoxSize inside=np.where(posc[:,1]<-BoxSize/2.0)[0] posc[inside,1]+=BoxSize inside=np.where(posc[:,2]>BoxSize/2.0)[0] posc[inside,2]-=BoxSize inside=np.where(posc[:,2]<-BoxSize/2.0)[0] posc[inside,2]+=BoxSize radii=np.sqrt(posc[:,0]**2+posc[:,1]**2+posc[:,2]**2) inside=np.where(radii<radius)[0] selected=random.sample(inside,Nsat) pos=pos[selected] #aditional, not esential check. Can be comment out posc=pos-position if np.any((posc>BoxSize/2.0) + (posc<-BoxSize/2.0)): inside=np.where(posc[:,0]>BoxSize/2.0)[0] posc[inside,0]-=BoxSize inside=np.where(posc[:,0]<-BoxSize/2.0)[0] posc[inside,0]+=BoxSize inside=np.where(posc[:,1]>BoxSize/2.0)[0] posc[inside,1]-=BoxSize inside=np.where(posc[:,1]<-BoxSize/2.0)[0] posc[inside,1]+=BoxSize inside=np.where(posc[:,2]>BoxSize/2.0)[0] posc[inside,2]-=BoxSize inside=np.where(posc[:,2]<-BoxSize/2.0)[0] posc[inside,2]+=BoxSize r_max=np.max(np.sqrt(posc[:,0]**2+posc[:,1]**2+posc[:,2]**2)) if r_max>radius: #check no particles beyond Rv selected print position print radius print pos count+=1 for j in range(Nsat): pos_galaxies[i]=pos[j]; i+=1 index+=1 if verbose: print 'done' #some final checks if i!=N_tot: print 'some galaxies missing:' print 'register',i,'galaxies out of',N_tot if count>0: print 'error:',count,'particles beyond the virial radius selected' return pos_galaxies
def compute_Pk(snapshot_fname, dims, do_RSD, axis, hydro): # 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) #h*km/s/Mpc h = head.hubble z = '%.3f' % redshift f_out = 'Pk_m_z=' + z + '.dat' # compute the values of Omega_CDM and Omega_B Omega_cdm = Nall[1] * Masses[1] / BoxSize**3 / rho_crit Omega_nu = Nall[2] * Masses[2] / BoxSize**3 / rho_crit Omega_b = Omega_m - Omega_cdm - Omega_nu print '\nOmega_CDM = %.4f\nOmega_B = %0.4f\nOmega_NU = %.4f'\ %(Omega_cdm,Omega_b,Omega_nu) print 'Omega_M = %.4f' % (Omega_m) # read the positions of all the particles pos = readsnap.read_block(snapshot_fname, "POS ", parttype=-1) / 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])) if do_RSD: print 'moving particles to redshift-space' # read the velocities of all the particles vel = readsnap.read_block(snapshot_fname, "VEL ", parttype=-1) #km/s RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis) del vel # read the masses of all the particles if not (hydro): Ntotal = np.sum(Nall, dtype=np.int64) #compute the number of particles 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 = readsnap.read_block(snapshot_fname, "MASS", parttype=-1) * 1e10 #Msun/h print '%.3e < M [Msun/h] < %.3e' % (np.min(M), np.max(M)) print 'Omega_M = %.4f\n' % (np.sum(M, dtype=np.float64) / rho_crit / BoxSize**3) # compute the mean mass per grid cell mean_M = np.sum(M, dtype=np.float64) / dims**3 # compute the mass within each grid cell delta = np.zeros(dims**3, dtype=np.float32) CIC.CIC_serial(pos, dims, BoxSize, delta, M) del pos print '%.6e should be equal to \n%.6e\n'\ %(np.sum(M,dtype=np.float64),np.sum(delta,dtype=np.float64)) del M # compute the density constrast within each grid cell delta /= mean_M delta -= 1.0 print '%.3e < delta < %.3e\n' % (np.min(delta), np.max(delta)) # compute the P(k) Pk = PSL.power_spectrum_given_delta(delta, dims, BoxSize) # write P(k) to output file np.savetxt(f_out, np.transpose([Pk[0], Pk[1]]))
Radii = np.array([5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41], dtype=np.float32) threshold = -0.7 threads1 = 16 threads2 = 4 void_field = True ############################################################################## # read snapshot head and obtain BoxSize, Omega_m and Omega_L head = readsnap.snapshot_header(snapshot) BoxSize = head.boxsize/1e3 #Mpc/h Radii = Radii*BoxSize/grid # read particle positions pos = readsnap.read_block(snapshot,"POS ",parttype=1)/1e3 #Mpc/h # compute density field delta = np.zeros((grid, grid, grid), dtype=np.float32) MASL.MA(pos, delta, BoxSize, MAS) delta /= np.mean(delta, dtype=np.float64); delta -= 1.0 # find the void V = VL.void_finder(delta, BoxSize, threshold, Radii, threads1, threads2, void_field=void_field) # void properties void_pos = V.void_pos #Mpc/h void_radius = V.void_radius #Mpc/h VSF_R = V.Rbins #VSF bins in radius VSF = V.void_vsf #VSF