def res (pars, **kwargs): A = pars['A'].value B = pars['B'].value C = pars['C'].value # displacing particles draw_particles(kwargs['pos'], kwargs['mass'], kwargs['npart'],kwargs['r'], kwargs['theta'], kwargs['phi'], A, B, C, kwargs['z']) pos_collapsed = np.repeat(kwargs['pos'], kwargs['npart'], axis=0) \ + np.transpose([kwargs['r']*np.sin(kwargs['theta'])*np.cos(kwargs['phi']), \ kwargs['r']*np.sin(kwargs['theta'])*np.sin(kwargs['phi']), \ kwargs['r']*np.cos(kwargs['theta'])]) pos_collapsed /= params.boxsize wrapPositions(pos_collapsed) pos_collapsed *= params.boxsize # Computing delta delta = np.copy(delta_uncollapsed) MASL.MA(pos_collapsed, delta, params.boxsize, 'CIC', verbose=False) Pk = PKL.Pk(delta, params.boxsize, 0, 'CIC', 1, verbose=False) # Getting only half of the values size = Pk.Nmodes3D.size//2 sigma = Pk.Pk[:size,0] * np.sqrt( (2.0/Pk.Nmodes3D[:size]) + kwargs['sigma_target']**2 ) return np.sum( ((Pk.Pk[:size,0] - kwargs['target']) / sigma)**2 )
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 compute_Pk(snapshot, grid, MAS, threads, ptype, root_out): # read header if not(os.path.exists(snapshot)): return 0 head = readgadget.header(snapshot) BoxSize = head.boxsize/1e3 #Mpc/h Nall = head.nall #Total number of particles Masses = head.massarr*1e10 #Masses of the particles in Msun/h Omega_m = head.omega_m Omega_l = head.omega_l redshift = head.redshift Hubble = 100.0*np.sqrt(Omega_m*(1.0+redshift)**3+Omega_l)#km/s/(Mpc/h) h = head.hubble Ntot = np.sum(Nall[ptype], dtype=np.int64) # get the name of the output file fout = '%s/Pk_%s_z=%.2f.txt'%(root_out, Pk_suffix(ptype), redshift) if os.path.exists(fout): return 0 # define the arrays containing the number positions and masses of the particles pos = np.zeros((Ntot,3), dtype=np.float32) mass = np.zeros(Ntot, dtype=np.float32) # read data for the different particle types f = h5py.File(snapshot, 'r'); offset = 0 for pt in ptype: # sometimes there are not black-holes or stars... if 'PartType%d'%pt not in f.keys(): continue # read positions pos_pt = f['PartType%d/Coordinates'%pt][:]/1e3 #Mpc/h if pos_pt.dtype==np.float64: pos_pt = pos_pt.astype(np.float32) # read masses if 'PartType%d/Masses'%pt in f: mass_pt = f['PartType%d/Masses'%pt][:]*1e10 #Msun/h else: mass_pt = np.ones(pos_pt.shape[0], dtype=np.float32)*Masses[1] #Msun/h # fill pos and mass arrays length = len(pos_pt) pos[offset:offset+length] = pos_pt mass[offset:offset+length] = mass_pt offset += length f.close() if offset!=Ntot: raise Exception('Not all particles counted') # calculate density field delta = np.zeros((grid,grid,grid), dtype=np.float32) MASL.MA(pos, delta, BoxSize, MAS, W=mass) delta /= np.mean(delta, dtype=np.float64); delta -= 1.0 # compute Pk and save results to file axis = 0 Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads) np.savetxt(fout, np.transpose([Pk.k3D, Pk.Pk[:,0]]), delimiter='\t')
def getG3power(sim, kmax): if z == 99: snap = sim + "/output/ics" elif z == 49: snap = sim + "/output/snapdir_000/PART_000" elif z == 9: snap = sim + "/output/snapdir_001/PART_001" elif z == 4: snap = sim + "/output/snapdir_002/PART_002" elif z == 3: snap = sim + "/output/snapdir_003/PART_003" elif z == 2: snap = sim + "/output/snapdir_005/PART_005" else: print("Don't have data for that redshift") quit() head = readsnap.snapshot_header(snap) rho_crit = 2.77536627e11 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 ## Pylian params grid = 512 ptypes = [1] MAS = 'CIC' do_RSD = False axis = 0 threads = 1 assert (z - redshift) < 0.001, "Redshift requested: %s, redshift found: %s" % ( z, redshift) Omega_cdm = Nall[1] * Masses[1] / BoxSize**3 / rho_crit Omega_b = Omega_m - Omega_cdm ## Calculate fractions f_b = Omega_b / (Omega_cdm + Omega_b) f_c = Omega_cdm / (Omega_cdm + Omega_b) ## CDM delta = MASL.density_field_gadget(snap, ptypes, grid, MAS, do_RSD, axis) delta /= np.mean(delta, dtype=np.float64) delta -= 1.0 print("Mean after normalising = %.2e" % np.mean(delta, dtype=np.float64)) Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads) # Calculate power k_sim = Pk.k3D Pk_sim = Pk.Pk[:, 0] Nmodes1D = Pk.Nmodes1D return k_sim[np.where(k_sim < kmax)], Pk_sim[np.where( k_sim < kmax)], BoxSize
def find_Pk(snapshot, grid, MAS, do_RSD, axis, threads, ptype, fpk, save_multipoles): if os.path.exists(fpk): return 0 # read header head = readgadget.header(snapshot) BoxSize = head.boxsize / 1e3 #Mpc/h Nall = head.nall #Total number of particles Masses = head.massarr * 1e10 #Masses of the particles in Msun/h Omega_m = head.omega_m Omega_l = head.omega_l redshift = head.redshift Hubble = 100.0 * np.sqrt(Omega_m * (1.0 + redshift)**3 + Omega_l) #km/s/(Mpc/h) h = head.hubble # read snapshot pos = readgadget.read_block(snapshot, "POS ", ptype) / 1e3 #Mpc/h # move particles to redshift-space if do_RSD: vel = readgadget.read_block(snapshot, "VEL ", ptype) #km/s RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis) # calculate Pk delta = np.zeros((grid, grid, grid), dtype=np.float32) if len(ptype) > 1: #for multiple particles read masses mass = np.zeros(pos.shape[0], dtype=np.float32) offset = 0 for j in ptype: mass[offset:offset + Nall[j]] = Masses[j] offset += Nall[j] MASL.MA(pos, delta, BoxSize, MAS, W=mass) else: MASL.MA(pos, delta, BoxSize, MAS) delta /= np.mean(delta, dtype=np.float64) delta -= 1.0 Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads) # save results to file if save_multipoles: np.savetxt(fpk, np.transpose( [Pk.k3D, Pk.Pk[:, 0], Pk.Pk[:, 1], Pk.Pk[:, 2]]), delimiter='\t') else: np.savetxt(fpk, np.transpose([Pk.k3D, Pk.Pk[:, 0]]), delimiter='\t')
def computePower(delta, realization): ''' Measure Powerspectrum. The output is saved in a txt file in the folder specified by output in initializeGlobals. delta : array_like input data, shape = (gridsize, gridsize, gridsize) realization: integer file format: k | P0(k) ''' filename = OutputDir + 'powerspectrum%i.dat' % realization print('\n Computing power, saving at ' + filename) Pkpyl = PKL.Pk(delta, BoxSize, axis, MAS, threads, verbose) np.savetxt(filename, np.vstack([Pkpyl.k3D, Pkpyl.Pk[:, 0]]).T)
def find_Pk(folder, snapdir, snapnum, grid, MAS, do_RSD, axis, threads, fixed_Mmin, Mmin, Nhalos, fpk, save_multipoles): if os.path.exists(fpk): return 0 # read header head = readgadget.header(snapdir) BoxSize = head.boxsize/1e3 #Mpc/h Omega_m = head.omega_m Omega_l = head.omega_l redshift = head.redshift Hubble = 100.0*np.sqrt(Omega_m*(1.0+redshift)**3+Omega_l)#km/s/(Mpc/h) h = head.hubble # read halo catalogue FoF = readfof.FoF_catalog(folder, snapnum, long_ids=False, swap=False, SFR=False, read_IDs=False) pos_h = FoF.GroupPos/1e3 #Mpc/h mass = FoF.GroupMass*1e10 #Msun/h vel_h = FoF.GroupVel*(1.0+redshift) #km/s if fixed_Mmin: indexes = np.where(mass>Mmin)[0] pos_h = pos_h[indexes]; vel_h = vel_h[indexes]; del indexes else: indexes = np.argsort(mass)[-Nhalos:] #take the Nhalos most massive halos pos_h = pos_h[indexes]; vel_h = vel_h[indexes]; del indexes # move halos to redshift-space if do_RSD: RSL.pos_redshift_space(pos_h, vel_h, BoxSize, Hubble, redshift, axis) # calculate Pk delta = np.zeros((grid,grid,grid), dtype=np.float32) MASL.MA(pos_h, delta, BoxSize, MAS) delta /= np.mean(delta, dtype=np.float64); delta -= 1.0 Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads) # save results to file hdr = ('Nhalos=%i BoxSize=%.3f'%(pos_h.shape[0],BoxSize)) if save_multipoles: np.savetxt(fpk, np.transpose([Pk.k3D, Pk.Pk[:,0], Pk.Pk[:,1], Pk.Pk[:,2]]), delimiter='\t', header=hdr) else: np.savetxt(fpk, np.transpose([Pk.k3D, Pk.Pk[:,0]]), delimiter='\t', header=hdr)
def compute_Pk_ICs(snapshot, grid, MAS, threads, ptype, root_out): if not(os.path.exists(snapshot)) and not(os.path.exists(snapshot+'.0')): return 0 # read header head = readgadget.header(snapshot) BoxSize = head.boxsize/1e3 #Mpc/h redshift = head.redshift # get the name of the file fout = '%s/Pk_%s_z=%.2f.txt'%(root_out, Pk_suffix(ptype), redshift) if os.path.exists(fout): return 0 # compute overdensity field do_RSD, axis = False, 0 delta = MASL.density_field_gadget(snapshot, ptype, grid, MAS, do_RSD, axis) delta /= np.mean(delta, dtype=np.float64); delta -= 1.0 # compute Pk and save results to file Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads) np.savetxt(fout, np.transpose([Pk.k3D, Pk.Pk[:,0]]), delimiter='\t')
def Mk(galaxy_pos, Filter, R, p, ds, BoxSize, grid, MAS, threads): ''' Measure the marked spectrum using the `Pylians3` package Input: galaxy_pos: (N,3) array FIlter: 'Top-Hat' or 'Gaussian' R: parameter of the mark: scale to define local density p: parameter of the mark ds: parameter of the mark BoxSize grid: scalar: size of the grid where we compute the density MAS: 'CIC' threads: scalar Output: Pk: object with power spectrum: k = Pk.k3D P0 = Pk.Pk[:,0] P2 = Pk.Pk[:,1] P4 = Pk.Pk[:,2] ''' # calculate delta delta = np.zeros((grid,grid,grid), dtype=np.float32) MASL.MA(galaxy_pos, delta, BoxSize, MAS) delta /= np.mean(delta, dtype=np.float64); delta -= 1.0 # smooth delta W_k = SL.FT_filter(BoxSize, R, grid, Filter, threads) delta_smoothed = SL.field_smoothing(delta, W_k, threads) # marks weight = np.zeros(galaxy_pos.shape[0], dtype=np.float32) MASL.CIC_interp(delta_smoothed, BoxSize, galaxy_pos, weight) mark = func_mark(weight,ds,p) delta_m = np.zeros((grid,grid,grid), dtype=np.float32) MASL.MA(galaxy_pos,delta_m,BoxSize,MAS,W=mark) delta_m /= np.mean(delta_m,dtype=np.float32); delta_m -= 1.0 # compute marked Pk Pk = PKL.Pk(delta_m, BoxSize, axis, MAS, threads) return Pk
def plot_power_spec(real_cube, generated_cube, threads=1, MAS="CIC", axis=0, BoxSize=75.0/2048*128): """Takes as input; - Real cube: (n x n x n) torch cuda FloatTensor, - Generated copy: (n x n x n) torch cuda FloatTensor, - constant assignments: threads, MAS, axis, BoxSize. Returns; - Power spectrum plots of both cubes in the same figure. """ ## Assert same type assert ((real_cube.type() == generated_cube.type())&(real_cube.type()=="torch.FloatTensor")),\ "Both input cubes should be torch.FloatTensor or torch.cuda().FloatTensor. Got real_cube type " + real_cube.type() + ", generated_cube type " + generated_cube.type() +"." ## Assert equal dimensions assert (real_cube.size() == generated_cube.size()),\ "Two input cubes must have the same size. Got real_cube size " + str(real_cube.size()) + ", generated cube size " + str(generated_cube.size()) ## if one or both of the cubes are cuda FloatTensors, detach them if real_cube.type() == "torch.cuda.FloatTensor": ## convert cuda FloatTensor to numpy array real_cube = real_cube.cpu().detach().numpy() else: real_cube = real_cube.numpy() if generated_cube.type() == "torch.cuda.FloatTensor": ## convert cuda FloatTensor to numpy array generated_cube = generated_cube.cpu().detach().numpy() else: generated_cube = generated_cube.numpy() # constant assignments BoxSize = BoxSize axis = axis MAS = MAS threads = threads # CALCULATE POWER SPECTRUM OF THE REAL CUBE # SHOULD WE DIVIDE BY WHOLE CUBE MEAN OR JUST THE MEAN OF THIS PORTION # Ask the Team # delta_real_cube /= mean_cube.astype(np.float64) delta_real_cube = real_cube delta_gen_cube = generated_cube delta_real_cube /= np.mean(delta_real_cube, dtype=np.float64) delta_real_cube -= 1.0 delta_real_cube = delta_real_cube.astype(np.float32) Pk_real_cube = PKL.Pk(delta_real_cube, BoxSize, axis, MAS, threads) # CALCULATE POWER SPECTRUM OF THE GENERATED CUBE delta_gen_cube /= np.mean(delta_gen_cube, dtype=np.float64) delta_gen_cube -= 1.0 delta_gen_cube = delta_gen_cube.astype(np.float32) Pk_gen_cube = PKL.Pk(delta_gen_cube, BoxSize, axis, MAS, threads) plt.figure(figsize=(10,5)) plt.plot(np.log(Pk_real_cube.k3D), np.log(Pk_real_cube.Pk[:,0]), color="b", label="original cube") plt.plot(np.log(Pk_gen_cube.k3D), np.log(Pk_gen_cube.Pk[:,0]), color="r", label="jaas") plt.rcParams["font.size"] = 12 plt.title("Power Spectrum Comparison") plt.xlabel('log(Pk.k3D)') plt.ylabel('log(Pk.k3D)') plt.legend() plt.show() return "Power spectrum plot complete!"
snapshot_root = '%s/output/' % run halos = groupcat.loadHalos( snapshot_root, snapnum, fields=['GroupPos', 'GroupMass', 'GroupVel']) halo_pos = halos['GroupPos'] / 1e3 #Mpc/h halo_mass = halos['GroupMass'] * 1e10 #Msun/h halo_vel = halos['GroupVel'] * (1.0 + z) #km/s del halos # move halo positions to redshift-space RSL.pos_redshift_space(halo_pos, halo_vel, BoxSize, Hubble, z, axis) print np.min(halo_pos[:, 0]), np.max(halo_pos[:, 0]) print np.min(halo_pos[:, 1]), np.max(halo_pos[:, 1]) print np.min(halo_pos[:, 2]), np.max(halo_pos[:, 2]) M_HI = M0 * (halo_mass / Mmin)**alpha * np.exp(-(Mmin / halo_mass)**(0.35)) delta_HI = np.zeros((dims, dims, dims), dtype=np.float32) MASL.MA(halo_pos, delta_HI, BoxSize, MAS, W=M_HI) delta_HI /= np.mean(delta_HI, dtype=np.float64) delta_HI -= 1.0 Pk = PKL.Pk(delta_HI, BoxSize, axis, MAS, 8) np.savetxt('Pk_HI_Nbody_redshift_space_%d_z=%.1f.txt' % (axis, z), np.transpose([Pk.k3D, Pk.Pk[:, 0]]))
'Pk_0.0eV_1000_reps_z=0.txt', 'Pk_0.0eV_1000_reps_1_z=0.txt', 'Pk_0.0eV_512_reps_z=0.txt', 'Pk_0.0eV_512_reps_1_z=0.txt', 'Pk_0.0eV_1000_2LPT_z=0.txt', 'Pk_0.0eV_1000_2LPT_1_z=0.txt', 'Pk_0.0eV_512_2LPT_z=0.txt', 'Pk_0.0eV_512_2LPT_1_z=0.txt' ] grid = 512 ptypes = [1] MAS = 'CIC' do_RSD = False axis = 0 threads = 1 verbose = True # do a loop over all snapshots for snapshot, fout in zip(snapshots, fouts): # read header header = readgadget.header(snapshot) BoxSize = header.boxsize / 1e3 #Mpc/h delta = MASL.density_field_gadget(snapshot, ptypes, grid, MAS, do_RSD, axis) delta /= np.mean(delta, dtype=np.float64) delta -= 1.0 # compute Pk Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads, verbose) np.savetxt(fout, np.transpose([Pk.k3D, Pk.Pk[:, 0]]))
grid = 256 #grid size, chose a small one for now because of RAM issues ptypes = [1] #we investigate the CDM + baryon power spectrum MAS = 'CIC' #Cloud-in-Cell do_RSD = False #dont do redshif-space distortions axis = 0 #axis along which place RSD; not used here verbose = True #whether print information on the progress BoxSize = 512 threads = 4 #calculate Pk for the 0.0eV reference run ref_delta = MASL.density_field_gadget(ref, ptypes, grid, MAS, do_RSD, axis, verbose) ref_delta /= np.mean(ref_delta, dtype=np.float64) ref_delta -= 1.0 ref_Pk = PKL.Pk(ref_delta, BoxSize, axis, MAS, threads, verbose) ref_k = ref_Pk.k3D ref_Pk0 = ref_Pk.Pk[:, 0] #calculate Pk for the reference run with given neutrino mass ref_mass_delta = MASL.density_field_gadget(ref_mass, ptypes, grid, MAS, do_RSD, axis, verbose) ref_mass_delta /= np.mean(ref_mass_delta, dtype=np.float64) ref_mass_delta -= 1.0 ref_mass_Pk = PKL.Pk(ref_mass_delta, BoxSize, axis, MAS, threads, verbose) ref_mass_k = ref_mass_Pk.k3D ref_mass_Pk0 = ref_mass_Pk.Pk[:, 0] #set up the figure fig, ax = plt.subplots(2, 2, figsize=(7, 7)) fig.suptitle(mass[:-1])
snapshot = '%s/output/snapdir_%03d/snap_%03d.%d.hdf5'\ %(run,snapnum,snapnum,i) f = h5py.File(snapshot, 'r') # read pos, radii, densities, HI/H and masses of gas particles pos = (f['PartType1/Coordinates'][:] / 1e3).astype(np.float32) vel = f['PartType1/Velocities'][:] * np.sqrt(scale_factor) # move gas particles to redshift-space RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis) ######## delta_c ######## MASL.MA(pos, delta_c, BoxSize, MAS) print 'i = %d' % i f = h5py.File(fout, 'w') f.create_dataset('delta_c', data=delta_c) f.close() delta_c /= np.mean(delta_c, dtype=np.float64) delta_c -= 1.0 Pk = PKL.Pk(delta_c, BoxSize, axis, 'CIC', threads=8) np.savetxt('Pk_CDM_RS_%d_z=%.1f.txt' % (axis, redshift), np.transpose([Pk.k3D, Pk.Pk[:, 0]])) np.savetxt('Pk2D_CDM_RS_%d_z=%.1f.txt' % (axis, redshift), np.transpose([Pk.kpar, Pk.kper, Pk.Pk2D]))
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]))
def __compute_powerspectrum(self): #{{{ Pk = PKL.Pk(self.data, self.BoxSize, 0, self.MAS, ARGS.threads) self.powerspectrum = { 'k': Pk.k1D, 'P': Pk1D, }
def getG3power(sim, kmax): ## Get desired redshift if z == 99: snap = sim + "/output/ics" elif z == 49: snap = sim + "/output/snapdir_000/PART_000" elif z == 9: snap = sim + "/output/snapdir_001/PART_001" elif z == 4: snap = sim + "/output/snapdir_002/PART_002" elif z == 3: snap = sim + "/output/snapdir_003/PART_003" elif z == 2: snap = sim + "/output/snapdir_005/PART_005" else: print("Don't have data for that redshift") quit() head = readsnap.snapshot_header(snap) rho_crit = 2.77536627e11 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 ## Pylian params grid = 256 ptypes = [1] MAS = 'CIC' do_RSD = False axis = 0 threads = 1 assert (z - redshift) < 0.001, "Redshift requested: %s, redshift found: %s" % ( z, redshift) Omega_cdm = Nall[1] * Masses[1] / BoxSize**3 / rho_crit Omega_b = Omega_m - Omega_cdm ## Calculate fractions f_b = Omega_b / (Omega_cdm + Omega_b) f_c = Omega_cdm / (Omega_cdm + Omega_b) ## CDM delta = MASL.density_field_gadget(snap, ptypes, grid, MAS, do_RSD, axis) delta /= np.mean(delta, dtype=np.float64) delta -= 1.0 print("Mean after normalising = %.2e" % np.mean(delta, dtype=np.float64)) Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads) # Calculate power k_sim = Pk.k3D Pk_sim = Pk.Pk[:, 0] Nmodes1D = Pk.Nmodes1D ## Baryons deltaby = MASL.density_field_gadget(snap, [0], grid, MAS, do_RSD, axis) deltaby /= np.mean(deltaby, dtype=np.float64) deltaby -= 1.0 print("Mean after normalising = %.2e" % np.mean(delta, dtype=np.float64)) Pkby = PKL.Pk(deltaby, BoxSize, axis, MAS, threads) # Calculate power k_simby = Pkby.k3D Pk_simby = Pkby.Pk[:, 0] Nmodes1D = Pk.Nmodes1D ## Make sure we can find total matter assert (np.mean(k_simby - k_sim) ) == 0.0, "k-arrays not equal, can't find total matter power" Pk_av = Pk_sim * f_c**2 + Pk_simby * f_b**2 + 2 * f_c * f_b * np.sqrt( Pk_sim * Pk_simby) return k_sim[np.where(k_sim < kmax)], Pk_simby[np.where( k_sim < kmax)], Pk_sim[np.where(k_sim < kmax)], Pk_av[np.where( k_sim < kmax)], BoxSize
# read the positions and velocities of the particles pos = readsnap.read_block(snapshot_fname,"POS ",parttype=1)/1e3 #Mpc/h vel = readsnap.read_block(snapshot_fname,"VEL ",parttype=1) #km/s # move particles to redshift-space RSL.pos_redshift_space(pos, vel, BoxSize, Hubble, redshift, axis) # compute density field in redshift-space delta = np.zeros((dims, dims, dims), dtype=np.float32) #this should be your density field MASL.MA(pos, delta, BoxSize, MAS='CIC') # computes the density in each cell of the grid delta = delta/np.mean(delta) - 1.0 # compute power spectra Pk = PKL.Pk(delta, BoxSize, axis, MAS='CIC', threads=cores) #Pk here is a class with all power spectra # 3D Pk k = Pk.k3D Pk0 = Pk.Pk[:,0] #monopole Pk2 = Pk.Pk[:,1] #quadrupole Pk4 = Pk.Pk[:,2] #hexadecapole Nmodes = Pk.Nmodes3D #number of modes in each Pk bin # 2D Pk kpar = Pk.kpar kperp = Pk.kper Pk2D = Pk.Pk2D Nmodes2D = Pk.Nmodes2D
def do_snap(snap): #load shapshot print('Loading snapshot', snap) snapshot_fname = '/cosma6/data/dp004/dc-smit4/Daemmerung/Planck2013-Npart_2048_Box_3000-Fiducial/run1/snapdir_{0:03d}/Planck2013-L3000-N2048-Fiducial_{0:03d}'.format( snap) density_fname = '/cosma6/data/dp004/dc-boot5/Lightcone/Density/density_{0:03d}.npy'.format( snap) powerspec_path = '/cosma6/data/dp004/dc-boot5/Lightcone/Power_Spectrum/' lightcone_path = "/cosma6/data/dp004/dc-boot5/Lightcone/Galaxy_FullSky/" #calculate density delta # declare the array hosting the density field density = np.zeros((dims, dims, dims), dtype=np.float32) # read relevant paramaters on the snapshot head = readgadget.header(snapshot_fname) BoxSize = head.boxsize / 1e3 #Mpc/h Masses = head.massarr * 1e10 #Msun/h Nall = head.nall filenum = head.filenum Omega_m = head.omega_m Omega_l = head.omega_l redshift = head.redshift fformat = head.format Hubble = head.Hubble Ntotal = np.sum(Nall, dtype=np.int64) grid = 2048 MAS = 'CIC' axis = 0 do_RSD = True BoxSize = 3000 #Mpc/h ptype = 1 #dark matter # do a loop over all files num = 0.0 for i in range(filenum): # find the name of the sub-snapshot if filenum == 1: snapshot = snapshot_fname else: snapshot = snapshot_fname + '.{0:d}'.format(i) if fformat == 'hdf5': snapshot = snapshot + '.hdf5' # find the local particles in the sub-snapshot head = readgadget.header(snapshot) npart = head.npart if verbose: print('Sub-snapshot {0:d}, DM particles = {1:d} \n'.format( i, npart[ptype])) if (DEBUG > 1 and i % 100 == 0): print( 'Sub-snapshot {0:d}, DM particles = {1:d}, time = {2:%H:%M:%S} \n' .format(i, npart[ptype], datetime.datetime.now())) # read positions in Mpc/h pos = readgadget.read_field(snapshot, "POS ", ptype) # read velocities in km/s if do_RSD: vel = readgadget.read_field(snapshot, "VEL ", ptype) # write galaxy data for each redshift bin into its own file fname = lightcone_path + 'galaxy_lightcone.snap{0:02d}'.format(snap) # open output file if (i == 0): mode = 'w' #open file in write mode for first file in snapshot else: mode = 'r+' #thereafter open in append mode fo = h5py.File(fname, mode) for oct in range(8): #relocate origin to each corner of the simulation box for each octant orig_x = oct % 2 * BoxSize orig_y = oct // 2 % 2 * BoxSize orig_z = oct // 4 * BoxSize # translate particle positions to new origin for each octant x = pos[::, 0] - orig_x y = pos[::, 1] - orig_y z = pos[::, 2] - orig_z # calculate comoving radial distance, RA and Dec r = np.sqrt(x * x + y * y + z * z) dec = np.rad2deg(np.arcsin(z / r)) ra = np.rad2deg(np.arctan2(y, x)) # lookup redshift corresponding to this r zz = d2z(r) if do_RSD: # Calculate radial velocity vr = np.sqrt(vel[::, 0]**2 + vel[::, 1]**2 + vel[::, 2]**2) * np.sign(vel[::, 0] + vel[::, 1] + vel[::, 2]) # Calculate RSD factor # Particle velocities u in internal velocity units (corresponds to km/sec if the default choice for the system of units is adopted). # Peculiar velocities v are obtained by multiplying u with sqrt(a), i.e. v = u * sqrt(a). So v = u / sqrt(1+z) f_RSD = np.sqrt(1 + zz) * vr / z2H(zz) else: f_RSD = np.zeros(len(r)) #Check whether particle within shell max and min sn = 63 - snap if (sn == 0): F = [(r <= Dc_max[sn])] else: F = [(r > Dc_max[sn - 1]) & (r <= Dc_max[sn])] f = tuple(F) # create random luminosity value for each particle ngal = len(pos) L = P2L(np.random.random(ngal) * n) # create dataset. Use f to filter only those galaxies within snapshot redshift boundaries g = np.array(list(zip(r[f], ra[f], dec[f], zz[f], f_RSD[f], L[f])), dtype=gal) ds_name = 'octant_{0:01d}'.format(oct) if (DEBUG > 3): print(ds_name) # if filenum = 0 then create new datasets for each octant and set dataset atributes if (i == 0): gals = fo.create_dataset( ds_name, data=g, dtype=gal, maxshape=(None, ), chunks=True ) # set maxshape = None to make resizeable and chunks = True to enable chunking gals.attrs['max_z'] = z_max[sn] if (sn == 0): gals.attrs['min_z'] = 0 else: gals.attrs['min_z'] = z_max[sn - 1] gals.attrs['snap'] = snap gals.attrs['octant'] = oct gals.attrs['alpha'] = alpha gals.attrs['phi_star'] = p_star elif (len(g) > 0): gals = fo[ds_name] gals.resize(gals.shape[0] + len(g), axis=0) gals[-len(g):] = g # end of processing for this octant fo.close() if (DEBUG > 2): print(fname, " completed, time:", datetime.datetime.now()) sys.stdout.flush() # compute density field. MASL.MA(pos, density, BoxSize, MAS) num += pos.shape[0] # All files read for snapshot if (DEBUG > 0): print(fname, " completed, time:", datetime.datetime.now()) # Write density field to file rho_avg = np.mean(density, dtype=np.float64) density /= rho_avg density -= 1.0 density.tofile(density_fname) if verbose: print( 'Density delta written to file for snap {0:d}, mean density = {1:04f}' .format(snap, rho_avg)) # Calculate power spectrum from density threads = 16 Pk = PKL.Pk(density, BoxSize, axis, MAS, threads) print('Pk calculated') #Save power spectra components in hdf5 file fname = 'powerspec_{0:03d}.npy'.format(snap) # open output file fo = h5py.File(powerspec_path + fname, 'w') # create datasets atts = fo.create_dataset( "attribs", dtype="f") # empty dataset for holding snapshot attributes atts.attrs['z'] = redshift atts.attrs['Omega_m'] = Omega_m atts.attrs['Omega_l'] = Omega_l # 1D P(k) dset = fo.create_dataset('k1D', data=Pk.k1D) dset = fo.create_dataset('Pk1D', data=Pk.Pk1D) dset = fo.create_dataset('Nmodes1D', data=Pk.Nmodes1D) # 2D P(k) dset = fo.create_dataset('kpar', data=Pk.kpar) dset = fo.create_dataset('kper', data=Pk.kper) dset = fo.create_dataset('Pk2D', data=Pk.Pk2D) dset = fo.create_dataset('Nmodes2D', data=Pk.Nmodes2D) # 3D P(k) dset = fo.create_dataset('k', data=Pk.k3D) dset = fo.create_dataset('Pk0', data=Pk.Pk[:, 0]) dset = fo.create_dataset('Pk2', data=Pk.Pk[:, 1]) dset = fo.create_dataset('Pk4', data=Pk.Pk[:, 2]) dset = fo.create_dataset('Nmodes', data=Pk.Nmodes3D) fo.close() print('Power spectrum data written to file')
import Pk_library as PKL import numpy as np import h5py test_cube = np.load('../dat/processed/test_cube_target.npy') pred_cube = np.load('../dat/processed/test_cube_final_prediction.npy') benchmark_cube = np.load('../dat/processed/benchmark_cube.npy') BoxSize = 31.82373046875 #Size of the density field in Mpc/h axis = 0 MAS = None threads = 32 Pk = PKL.Pk(test_cube, BoxSize, axis, MAS, threads) k = Pk.k3D Pk0 = Pk.Pk[:, 0] #monopole np.save('../dat/processed/target_k_values.npy', k) np.save('../dat/processed/target_Pk0_values.npy', Pk0) Pk = PKL.Pk(pred_cube, BoxSize, axis, MAS, threads) # 3D P(k) k = Pk.k3D Pk0 = Pk.Pk[:, 0] #monopole np.save('../dat/processed/' + 'pred_k_values.npy', k) np.save('../dat/processed/' + 'pred_Pk0_values.npy', Pk0) Pk = PKL.Pk(benchmark_cube, BoxSize, axis, MAS, threads)
#~ fid_file.close() #~ else : #~ with open(cname, 'a') as fid_file: #~ fid_file.write('%.8g %.8g %.8g %.8g\n' % ( np.sum(Hmass_a),np.sum(Hmass_b), np.sum(Hmass_c), np.sum(Hmass_d))) #~ fid_file.close() ############################################################### ######## fourth mass range ############################################################### delta1d = np.zeros((dims, dims, dims), dtype=np.float32) MASL.MA(pos[Hmass_ind_d], delta1d, BoxSize, MAS='CIC', W=None) delta1d = delta1d / np.mean(delta1d, dtype=np.float64) - 1.0 # compute power spectra Pk1d = PKL.Pk(delta1d, BoxSize, axis=0, MAS='CIC', threads=4) #Pk here is a class with all power spectra #shot noise Pshot_m4 = 1 / (len(Hmass_d) / BoxSize**3) # 3D Pk k_m4 = Pk1d.k3D #~ Pk0_m4 = (Pk1d.Pk[:,0] + Pk2d.Pk[:,0] + Pk3d.Pk[:,0] + Pk5d.Pk[:,0] + Pk6d.Pk[:,0] + Pk7d.Pk[:,0] + Pk8d.Pk[:,0])/7 #monopole #~ Pk2_m4 = (Pk1d.Pk[:,1] + Pk2d.Pk[:,1] + Pk3d.Pk[:,1] + Pk5d.Pk[:,1] + Pk6d.Pk[:,1] + Pk7d.Pk[:,1] + Pk8d.Pk[:,1])/7 #quadrupole #~ Pk4_m4 = (Pk1d.Pk[:,2] + Pk2d.Pk[:,2] + Pk3d.Pk[:,2] + Pk5d.Pk[:,2] + Pk6d.Pk[:,2] + Pk7d.Pk[:,2] + Pk8d.Pk[:,2])/7 #hexadecapole #~ Nmodes_m4 = (Pk1d.Nmodes3D + Pk2d.Nmodes3D + Pk3d.Nmodes3D + Pk5d.Nmodes3D + Pk6d.Nmodes3D + Pk7d.Nmodes3D + Pk8d.Nmodes3D)/7 #number of modes in each Pk bin #~ temp4 = np.array([Pk1d.Pk[:,0], Pk2d.Pk[:,0], Pk3d.Pk[:,0], Pk5d.Pk[:,0], Pk6d.Pk[:,0], Pk7d.Pk[:,0], Pk8d.Pk[:,0]]) #~ std4 = np.std(temp4, axis=0) cname = '/home/dvalcin/plots/Phh4_realisation_' + str( Mnu) + '_z=' + str(z) + '.txt'
def plot_power_spec( real_cube, # should be inverse_transformed generated_cube, # should be inverse_transformed raw_cube_mean, # mean of the whole raw data cube (fields=z0.0) threads=1, MAS="CIC", axis=0, BoxSize=75.0 / 2048 * 128): """Takes as input; - Real cube: (batch_size x 1 x n x n x n) torch cuda FloatTensor, - Generated copy: (batch_size x 1 x n x n x n) torch cuda FloatTensor, - constant assignments: threads, MAS, axis, BoxSize. Returns; - Power spectrum plots of both cubes in the same figure. """ print("number of samples of real and generated cubes = " + str(real_cube.shape[0])) ## Assert same type assert ((real_cube.type() == generated_cube.type())&(real_cube.type()=="torch.FloatTensor")),\ "Both input cubes should be torch.FloatTensor or torch.cuda().FloatTensor. Got real_cube type " + real_cube.type() + ", generated_cube type " + generated_cube.type() +"." ## Assert equal dimensions assert (real_cube.size() == generated_cube.size()),\ "Two input cubes must have the same size. Got real_cube size " + str(real_cube.size()) + ", generated cube size " + str(generated_cube.size()) ## if one or both of the cubes are cuda FloatTensors, detach them if real_cube.type() == "torch.cuda.FloatTensor": ## convert cuda FloatTensor to numpy array real_cube = real_cube.cpu().detach().numpy() else: real_cube = real_cube.numpy() if generated_cube.type() == "torch.cuda.FloatTensor": ## convert cuda FloatTensor to numpy array generated_cube = generated_cube.cpu().detach().numpy() else: generated_cube = generated_cube.numpy() # constant assignments BoxSize = BoxSize axis = axis MAS = MAS threads = threads plt.figure(figsize=(10, 5)) for cube_no in range(real.shape[0]): delta_real_cube = real_cube[cube_no] delta_gen_cube = generated_cube[cube_no] # CALCULATE POWER SPECTRUM OF THE REAL CUBE # delta_real_cube /= np.mean(delta_real_cube, # dtype=np.float64) delta_real_cube /= raw_cube_mean delta_real_cube -= 1.0 delta_real_cube = delta_real_cube.astype(np.float32) Pk_real_cube = PKL.Pk(delta_real_cube, BoxSize, axis, MAS, threads) # CALCULATE POWER SPECTRUM OF THE GENERATED CUBE # delta_gen_cube /= np.mean(delta_gen_cube, # dtype=np.float64) delta_gen_cube /= raw_cube_mean delta_gen_cube -= 1.0 delta_gen_cube = delta_gen_cube.astype(np.float32) Pk_gen_cube = PKL.Pk(delta_gen_cube, BoxSize, axis, MAS, threads) plt.plot(np.log(Pk_real_cube.k3D), np.log(Pk_real_cube.Pk[:, 0]), color="b", label="original cube") plt.plot(np.log(Pk_gen_cube.k3D), np.log(Pk_gen_cube.Pk[:, 0]), color="r", label="jaas") plt.rcParams["font.size"] = 12 plt.title("Power Spectrum Comparison") plt.xlabel('log(Pk.k3D)') plt.ylabel('log(Pk.k3D)') plt.legend() plt.show() return "Power spectrum plot complete!"
import sys snapshot = sys.argv[1] #'fR5_mnu016_DUSTGRAIN_snap_463' BoxSize = float(sys.argv[2]) #2000.0 #Mpc/h grid = long(sys.argv[3]) #1024 ptypes = map(int,sys.argv[4].split(",")) MAS = 'CIC' do_RSD = False axis = 0 threads=1 ## First do the total Power Spectrum delta = MASL.density_field_gadget(snapshot, ptypes, grid, MAS, do_RSD, axis) delta /= np.mean(delta, dtype=np.float64); delta -= 1.0 Pk = PKL.Pk(delta, BoxSize, axis, MAS, threads) # 1D P(k) k1D = Pk.k1D Pk1D = Pk.Pk1D Nmodes1D = Pk.Nmodes1D # 2D P(k) kpar = Pk.kpar kper = Pk.kper Pk2D = Pk.Pk2D Nmodes2D = Pk.Nmodes2D # 3D P(k) k = Pk.k3D Pk0 = Pk.Pk[:,0] #monopole Pk2 = Pk.Pk[:,1] #quadrupole
#~ plt.yscale('log') #~ plt.xscale('log') #~ plt.show() #~ plt.savefig('/home/dvalcin/plots/cumul_halo_mass_funct_at_z= '+str(z)+'.png', dpi = 500) ##~ ################################################################## #~ ########## First mass range #~ ################################################################## delta1a = np.zeros((dims, dims, dims), dtype=np.float32) MASL.MA(pos[Hmass_ind_a], delta1a, BoxSize, MAS='CIC', W=None) delta1a = delta1a / np.mean(delta1a, dtype=np.float64) - 1.0 # compute power spectra Pk1a = PKL.Pk( delta1a, BoxSize, axis=axe, MAS='CIC', threads=4) #Pk here is a class with all power spectra #shot noise Pshot_m1 = 1 / (len(Hmass_a) / BoxSize**3) # 3D Pk k_m1 = Pk1a.k3D #~ Pk0_m1 = (Pk1a.Pk[:,0] + Pk2a.Pk[:,0] + Pk3a.Pk[:,0] + Pk5a.Pk[:,0] + Pk6a.Pk[:,0] + Pk7a.Pk[:,0] + Pk8a.Pk[:,0])/7 #monopole #~ Pk2_m1 = (Pk1a.Pk[:,1] + Pk2a.Pk[:,1] + Pk3a.Pk[:,1] + Pk5a.Pk[:,1] + Pk6a.Pk[:,1] + Pk7a.Pk[:,1] + Pk8a.Pk[:,1])/7 #quadrupole #~ Pk4_m1 = (Pk1a.Pk[:,2] + Pk2a.Pk[:,2] + Pk3a.Pk[:,2] + Pk5a.Pk[:,2] + Pk6a.Pk[:,2] + Pk7a.Pk[:,2] + Pk8a.Pk[:,2])/7 #hexadecapole #~ Nmodes_m1 = (Pk1a.Nmodes3D + Pk2a.Nmodes3D + Pk3a.Nmodes3D + Pk5a.Nmodes3D + Pk6a.Nmodes3D + Pk7a.Nmodes3D + Pk8a.Nmodes3D)/7 #number of modes in each Pk bin #~ temp1 = np.array([Pk1a.Pk[:,0], Pk2a.Pk[:,0], Pk3a.Pk[:,0], Pk5a.Pk[:,0], Pk6a.Pk[:,0], Pk7a.Pk[:,0], Pk8a.Pk[:,0]]) #~ std1 = np.std(temp1, axis=0)