def diff_comoving_volume(z): cosmo = FlatLambdaCDM(H0=70, Om0=0.3, Tcmb0=2.725) H0 = cosmo.H(0).value # km / s / Mpc dl = cosmo.luminosity_distance(z).value lightspeed = c * 0.001 # convert from m/s to km/s ez = np.sqrt(cosmo.Om(0) * ((1 + z)**3) + (1 - cosmo.Om(0))) dv = 4 * np.pi * (lightspeed / H0) * (dl**2) / ((1 + z)**2) / ez dv = dv * ((0.001)**3) # Mpc^3 to Gpc^3 # Test case #dv_new = cosmo.differential_comoving_volume(3) #print (4 * np.pi * dv_new.value) return dv
def Sigmabar_NFW_r(r, z, Mvir, cvir, Delta_C=None, cosmo=None): """ %%%%%%%%% % sigma=Sigmabar_NFW(r,z,Mvir,cvir) % NFW Sigma in Msun/Mpc^2 in shells of theta % (using Shimizu etal 2003?; Wright & Brainerd) %%%%%%%%% """ if cosmo is None: cosmo = FlatLambdaCDM( H0=70, Om0=0.3, ) if Delta_C is None: Delta_C = c.Delta_vir(z, cosmo) * cosmo.Om(z) rho_cz = cosmo.critical_density(z).to(u.M_sun / u.Mpc**3.0) delta_cvir = c.delta_c(cvir, Delta_C) rvir = (Mvir / (4. * np.pi / 3. * rho_cz * Delta_C))**( 1. / 3) # wrt critical density rs = rvir / cvir x = r / rs cscale = 2 * rs * delta_cvir * rho_cz kappabar = kappabar_NFW(x) sigmabar = kappabar * cscale return sigmabar
def Delta_vir(z, cosmo=None): if cosmo is None: cosmo = FlatLambdaCDM( H0=70, Om0=0.3, ) wf = (1 / cosmo.Om(z) - 1) Delta_vir = 18. * np.pi**2. * (1 + 0.40929 * wf**0.90524) return Delta_vir
def rvir_NFW(z, Mvir, Delta_C=None, cosmo=None): if cosmo is None: cosmo = FlatLambdaCDM( H0=70, Om0=0.3, ) if Delta_C is None: Delta_C = c.Delta_vir(z, cosmo) * cosmo.Om(z) rho_cz = cosmo.critical_density(z).to(u.M_sun / u.Mpc**3.) rvir = (Mvir / (4. * np.pi / 3. * rho_cz * Delta_C))**(1. / 3.) return rvir
def ks_gnfw(r, z, zs, Mvir, cvir, Delta_C=None, cosmo=None): if cosmo is None: cosmo = FlatLambdaCDM( H0=70, Om0=0.3, ) if Delta_C is None: Delta_C = c.Delta_vir(z, cosmo) * cosmo.Om(z) rho_cz = cosmo.critical_density(z).to(u.M_sun / u.Mpc**3) delta_cvir = c.delta_c(cvir, Delta_C) rvir = rvir_NFW(z, Mvir, Delta_C, cosmo) rs = rvir / cvir ks_gnfw = 2 * rs * delta_cvir * rho_cz / c.Sigma_crit(z, zs, cosmo) return ks_gnfw
class Growth(object): """ """ gamma_fid = 0.55 def __init__(self, om=0.307115, omb=0.048206, sig8=0.8228, zmax=5, amax=4): """ """ self.om = om self.omb = omb self.sig8 = sig8 self.zmax = zmax self.amax = amax self.zmin = 1./amax - 1 self.cosmo = FlatLambdaCDM(100, self.om, Ob0=self.omb) logamin = - np.log(1+zmax) loga = np.linspace(np.log10(amax), logamin, 1000) z = 1./np.exp(loga) - 1 self._omz = self.cosmo.Om(z) self._z = z self._zmid = (z[1:]+z[:-1])/2. self._logastep = loga[1] - loga[0] f = self._omz**self.gamma_fid logdelta = integrate.cumtrapz(f, dx=self._logastep) g = np.exp(logdelta) fid = interpolate.interp1d(self._zmid, g, bounds_error=False, fill_value=(g[0],g[-1])) g0 = fid(0) g = sig8 * g / g0 self.fid = interpolate.interp1d(self._zmid, g, bounds_error=False, fill_value=(g[0],g[-1])) self.fid_inv = interpolate.interp1d(g, self._zmid,bounds_error=False, fill_value=(z[0],z[-1])) logging.info("growth range %f %f", z[0],z[-1]) logging.info("growth sig8 %f", self.fid(0)) def init_from_class(self): """ """ class_params = { 'output': 'mPk', 'non linear': '', 'z_max_pk': self.zmax, 'Omega_b': self.omb, 'Omega_cdm': self.om-self.omb, } self.cosmo_class = Class() self.cosmo_class.set(class_params) self.cosmo_class.compute() zz = np.linspace(0,self.zmax,100) s8z = [] for z in zz: s8z.append(self.sig8 * self.cosmo_class.scale_independent_growth_factor(z)) self.fid = interpolate.interp1d(zz, s8z) self.fid_inv = interpolate.interp1d(s8z,zz) def __call__(self, z, sig8_0=None, gamma=None): """ """ if np.any(z > self.zmax): raise ValueError if np.any(z < self.zmin): raise ValueError if sig8_0 is None: sig8_0 = self.sig8 if gamma is None: gamma = self.gamma_fid f = self._omz**gamma if not np.all(np.isfinite(f)): raise ValueError logdelta = integrate.cumtrapz(f, dx=self._logastep) g = np.exp(logdelta) if not np.all(np.isfinite(g)): raise ValueError func = interpolate.interp1d(self._zmid, g, bounds_error=False, fill_value=(g[0],g[-1])) f0 = func(0) if f0 == 0: raise ValueError if not np.isfinite(f0): raise ValueError return func(z) / f0 * sig8_0
(p)) * (delta_c * a**0.5 / sigma)**(q) * n.e**(-a * delta_c**2. / (2. * sigma**2.)) X = n.arange(-0.6, 0.5, 0.01) #n.log10(1./sigma) sigma = 10**-X hz = cosmo.H(boxRedshift).value / 100. # m sigma relation using the sigma8 corrected power spectrum m2sigma = interp1d(hf.M, hf.sigma) # m nu relation: nu = (delta_c / sigma_m)**2 m2nu = interp1d(hf.M, hf.nu) # jacobian toderive = interp1d(n.log(hf.M), n.log(hf.sigma)) mass = hf.M[100:-100] dlnsigmadlnm = derivative(toderive, n.log(mass)) rhom_units = cosmo.Om(boxRedshift) * cosmo.critical_density(boxRedshift).to( u.solMass / (u.Mpc)**3.) #/(cosmo.h)**2. # in units (Msun/h) / (Mpc/h)**3 rhom = rhom_units.value # hf.mean_density#/(hz)**2. ftC16 = f_BH(hf.sigma[100:-100], 0.279, 0.908, 0.671, 1.737) MF_MD = interp1d(mass, ftC16 * rhom * abs(dlnsigmadlnm) / mass) NpartMin = 50. p_init = (-1.85, -2.3) env = os.environ['MD10'] sat_in_cen_d1 = join(env, "substructure", "out_0.74980_subH_inDistinct_d1.fits") sat_in_cen_d2 = join(env, "substructure",
class PowerTemplate: def __init__(self, z=0.5, ombhsq=0.02222, omhsq=0.14212, sigma8=0.830, h=0.6726, ns=0.9652, Tcmb0=2.725): self.z = z self.h = h self.ombhsq = ombhsq # Omega matter baryon self.omhsq = omhsq # Omega matter (baryon + CDM) self.om = omhsq / np.square(h) self.omb = ombhsq / np.square(h) self.cosmology = FlatLambdaCDM(H0=100 * h, Om0=self.om, Tcmb0=Tcmb0, Ob0=self.omb) self.ol = 1 - self.omhsq / np.square(h) # ignring radiation density self.sigma8 = sigma8 self.ns = ns self.Tcmb0 = 2.725 self.Rscale = 8 self.P0smooth = 1 # initial value for the coefficient self.P0smooth = np.square(sigma8 / self.siglogsmooth()) # correction def T0(self, k): ''' Zero-baryon transfer function shape from E&H98, input k in h/Mpc ''' k = k * self.h # convert unit of k from h/Mpc to 1/Mpc # Eqn 26, approximate sound horizon in Mpc s = 44.5 * np.log( 9.83 / self.omhsq) / np.sqrt(1 + 10 * np.power(self.ombhsq, 3 / 4)) # Eqn 28, both dimensionless Theta = self.Tcmb0 / 2.7 # Eqn 31, alpha_gamma, dimensionless agam = 1 - 0.328 * np.log(431*self.omhsq) * self.ombhsq/self.omhsq \ + 0.38*np.log(22.3*self.omhsq) * np.square(self.ombhsq/self.omhsq) # Eqn 30, in unit of h gamma_eff = self.omhsq / self.h * ( agam + (1 - agam) / np.power(1 + (0.43 * k * s), 4)) q = k / self.h * np.square(Theta) / gamma_eff C0 = 14.2 + 731 / (1 + (62.5 * q)) # Eqn 29 L0 = np.log(2 * np.e + 1.8 * q) T0 = L0 / (L0 + C0 * np.square(q)) return T0 def siglogsmooth(self, tol=1e-10): '''rms mass fluctuations (integrated in logspace) for sig8 etc. NOTES: formalism is all real-space distance in Mpc/h, all k in h/Mpc ''' return np.sqrt(romberg(self.intefunclogsmooth, -10, 10, tol=tol)) def intefunclogsmooth(self, logk): """ Function to integrate to get rms mass fluctuations (logspace) base 10 NOTES: Because the k's here are all expressed in h/Mpc the value of P0 that arises using this integration is in (Mpc**3)/(h**3.) and therefore values of P(k) derived from this integration are in (Mpc**3)/(h**3.), i.e. h^-3Mpc^3 and need divided by h^3 to get the 'absolute' P(k) in Mpc^3. v1.0 Adam D. Myers Jan 2007 """ k = np.power(10.0, logk) # base 10 kR = k * self.Rscale integrand = np.log(10) / (2*np.square(np.pi)) * np.power(k, 3) \ * self.Psmooth(k) * np.square(W(kR)) return integrand def Psmooth(self, k): """ Baryonic Linear power spectrum SHAPE, pass k in h/Mpc """ om = self.om ol = self.ol omz = self.cosmology.Om(self.z) # Omega matter at z olz = ol / np.square(self.cosmology.efunc(self.z)) # MBW Eqn 3.77 g0 = 5 / 2 * om / (np.power(om, 4 / 7) - ol + ((1 + om / 2) * (1 + ol / 70))) # Eqn 4.76 gz = 5 / 2 * omz / (np.power(omz, 4 / 7) - olz + ((1 + omz / 2) * (1 + olz / 70))) Dlin_ratio = gz / (1 + self.z) / g0 Psmooth = self.P0smooth * np.square(self.T0(k)) * \ np.power(k, self.ns) * np.square(Dlin_ratio) return Psmooth def P(self, k_lin, P_lin, n_mu_bins, beta=0, Sigma_s=4, Sigma_r=15, Sigma_perp=0, Sigma_para=0): """ This is the final power template from P_lin and P_nw including the C and exponential damping terms input k, P are 1D arrays from CAMB, n_mu_bins is an integer default beta = 0.4, dimensionless """ self.k = k_lin # 1D array self.P_lin = P_lin # 1D array self.P_nw = self.Psmooth(k_lin) # 1D array self.mu_bins = np.linspace(0, 1, num=n_mu_bins + 1) # 1D bin edges self.mu = (self.mu_bins[1:] + self.mu_bins[:-1]) / 2 # 1D bin centres mu, k = np.meshgrid(self.mu, k_lin) # 2D meshgrid P_lin = np.tile(P_lin, (n_mu_bins, 1)).T # meshgrid P_nw = self.Psmooth(k) # follows meshgrid shape of k_lin try: assert P_lin.size == P_nw.size except AssertionError: print('P shapes are', P_lin.shape, P_nw.shape) sigmavsq = (1 - np.square(mu))*np.square(Sigma_perp)/2 \ + np.square(mu*Sigma_para)/2 # BAO peak smoothing due to nonlinear S = np.exp(-np.square(k * Sigma_r) / 2) C = (1 + np.square(mu) * beta * (1-S)) / \ (1 + np.square(k*mu*Sigma_s)/2) self.P_k_mu = np.square(C) * ( (P_lin - P_nw) * np.exp(-np.square(k) * sigmavsq) + P_nw) return self.P_k_mu def p_multipole(self, ell): Ln = legendre(ell) P_ell = (2 * ell + 1) / 2 * np.sum( self.P_k_mu * (Ln(-self.mu) + Ln(self.mu)) * np.diff(self.mu_bins), axis=1) return P_ell def xi_multipole(self, r_input, ell, a=0.34, r_damp=True): ''' integrate in logk space using trapozoidal rule a is the exponential damping parameter to suppress high-k oscillations usually 0.3 to 1 input r may be 2D of dim (n_r_bins, n_mu_bins) ''' P_ell = self.p_multipole(ell) P_ell = (P_ell[1:] + P_ell[:-1]) / 2 # interpolate midpoint dk = np.diff(self.k) lnk_edges = np.log(self.k) lnk = (lnk_edges[1:] + lnk_edges[:-1]) / 2 # lnk value at midpoint k = np.exp(lnk) # k value at midpoint # turn into 2D grids k = np.tile(k, (r_input.size, 1)) P_ell = np.tile(P_ell, (r_input.size, 1)) dk = np.tile(dk, (r_input.size, 1)) r = np.tile(r_input.flatten(), (k.shape[1], 1)).T assert k.shape == P_ell.shape == dk.shape == r.shape if r_damp: damp = np.exp(-r * np.square(k * a)) else: damp = np.exp(-np.square(k * a)) xi_ell = np.power(1j, ell) / (2 * np.square(np.pi)) * np.sum( np.square(k) * P_ell * spherical_jn(ell, k * r) * damp * dk, axis=1) return np.real(xi_ell.reshape(r_input.shape))
def main(): ######################################################################## # Parameters. # ######################################################################## # Parameters for survey cone rmin = 0. # Minimum R.A. of survey [deg] rmax = 90. # Maximum R.A. of survey [deg] dmin = 30. # Minimum Dec. of survey [deg] dmax = 90. # Maximum Dec. of survey [deg] zmin = 0.2 # Minimum redshift of survey zmax = 0.6 # Maximum redshift of survey # Parameters applied to intensity map nside = 128 # Healpix resolution for angular pixelization dzbin = 0.005 # Width of redshift bins ngrid = 256 # Grid size of FFT dobeam = True # Convolve with telescope beam sigdeg = 1. # Standard deviation of telescope beam [deg] donoise = True # Include noise in temperature map signoise = 0.3 # Gaussian noise per cell dofg = False # Read in data with foregrounds, and apply subtraction # Parameters applied to galaxy map winfile = 'winx_MICEv2-ELGs.dat' # Window function # Parameters for power spectrum estimation doconv = False # Determine full convolution with window kmin = 0. # Minimum wavenumber [h/Mpc] kmax = 0.3 # Maximum wavenumber [h/Mpc] nkbin = 30 # Number of Fourier bins binopt = 1 # 1) power spectrum multipoles # 2) power spectrum wedges P(k,mu) # 3) 2D power spectrum P(k_perp,k_par) nwedge = 4 # Number of wedges if binopt=2 kmin2 = 0. # Minimum wavenumber for 2D power if binopt=3 kmax2 = 0.18 # Maximum wavenumber for 2D power if binopt=3 nk2d = 9 # Number of bins for 2D power if binopt=3 # Parameters for cosmological model om = 0.25 # Matter density bgal = 1.17 # Bias of galaxy sample bdens = 1.09 # Bias of intensity sample # RSD distortion parameters cosmo = FlatLambdaCDM(H0=100.,Om0=om) zeff = 0.5*(zmin+zmax) ffid = cosmo.Om(zeff)**0.55 betagal = ffid/bgal # RSD distortion parameter of galaxy sample betadens = ffid/bdens# RSD distortion parameter of intensity sample sigvgal = 260. # Pairwise velocity dispersion of galaxies [km/s] sigvdens = 440. # Pairwise velocity dispersion of HI [km/s] pkmodfile = 'pkcambhalofit_zeq0pt4_mice.dat' # Model power spectrum ######################################################################## # Initializations. # ######################################################################## data = np.loadtxt(pkmodfile) kmod,pkmod = data[:,0],data[:,1] nx,ny,nz = ngrid,ngrid,ngrid dobound = False nzbin = int(np.rint((zmax-zmin)/dzbin)) zlims = np.linspace(zmin,zmax,nzbin+1) ######################################################################## # Get angular healpix window function. # ######################################################################## data = np.loadtxt('pixwin_nside128.dat') lwin,pixwin = data[:,0],data[:,1] ######################################################################## # Dimensions of FFT cuboid for embedding the survey cone. # ######################################################################## lx,ly,lz,x0,y0,z0 = boxtools.boxsize(zmin,zmax,dobound,rmin,rmax,dmin,dmax,cosmo) vol,nc = lx*ly*lz,nx*ny*nz vpix = vol/nc ######################################################################## # Read in MICE intensity mapping data. # ######################################################################## denshpz,winhpz,ipixlst,npix = micetools.readmiceintmap(nzbin,nside,dzbin,zmin,zmax,dofg) ######################################################################## # Determine noise power spectrum. # ######################################################################## if (donoise): signoisez = sphertools.getsignoisez(nside,nzbin,zlims,signoise,vpix,cosmo) pknoise = sphertools.calcpknoisehpz(nside,nzbin,zlims,signoise,True,signoisez,npix,cosmo) else: pknoise = 0. ######################################################################## # Add noise to the field. # ######################################################################## if (donoise): denshpz += sphertools.getnoisehpz(nzbin,ipixlst,signoise,True,signoisez) ######################################################################## # Convolve the field with the telescope beam. # ######################################################################## if (dobeam): denshpz = sphertools.convhpzbeam(nside,ipixlst,nzbin,denshpz,sigdeg) ######################################################################## # Run foreground subtraction. # ######################################################################## if (dofg): denshpz = micetools.cleanFG(denshpz,N_IC=4) ######################################################################## # Convert the field from the (redshift,healpix) map to the FFT grid. # ######################################################################## densgrid,wingriddens = hppixtogrid.hppixtogrid(nzbin,nside,denshpz,winhpz,ipixlst,zlims,dobound,rmin,rmax,dmin,dmax,nx,ny,nz,lx,ly,lz,x0,y0,z0,cosmo) ######################################################################## # Read in and grid MICE galaxy data and window function. # ######################################################################## ras,dec,red,ngal = micetools.readmicegalcat(zmin,zmax) dxpos,dypos,dzpos = boxtools.getxyz(dobound,rmin,rmax,dmin,dmax,ras,dec,red,cosmo) galgrid = boxtools.discret(dxpos,dypos,dzpos,nx,ny,nz,lx,ly,lz,x0,y0,z0) wingridgal = boxtools.readwin(winfile,nx,ny,nz,lx,ly,lz) ######################################################################## # Measure the auto- and cross-power spectrum multipoles. # ######################################################################## pk0gal,pk2gal,pk4gal,pk0dens,pk2dens,pk4dens,pk0cross,pk2cross,pk4cross,pk0errgal,pk2errgal,pk4errgal,pk0errdens,pk2errdens,pk4errdens,pk0errcross,pk2errcross,pk4errcross,pk0congal,pk2congal,pk4congal,pk0condens,pk2condens,pk4condens,pk0concross,pk2concross,pk4concross = measpk.measpk(doconv,galgrid,wingridgal,densgrid,wingriddens,nx,ny,nz,lx,ly,lz,x0,y0,z0,kmin,kmax,nkbin,kmod,pkmod,betagal,betadens,sigvgal,sigvdens,bgal,bdens,pknoise,dobeam,sigdeg,lwin,pixwin,dzbin,cosmo) ######################################################################## # Read in power spectrum dataset (if it has been written out). # ######################################################################## # pkfile = 'pkpole.dat' # kmin,kmax,nkbin,kbin,pk0gal,pk2gal,pk4gal,pk0dens,pk2dens,pk4dens,pk0cross,pk2cross,pk4cross,pk0errgal,pk2errgal,pk4errgal,pk0errdens,pk2errdens,pk4errdens,pk0errcross,pk2errcross,pk4errcross,pk0modgal,pk2modgal,pk4modgal,pk0moddens,pk2moddens,pk4moddens,pk0modcross,pk2modcross,pk4modcross,pk0congal,pk2congal,pk4congal,pk0condens,pk2condens,pk4condens,pk0concross,pk2concross,pk4concross = pktools.readpolecross(pkfile) ######################################################################## # Convert from multipoles to P(k,mu) or P(kperp,kpar). # ######################################################################## if ((binopt == 2) or (binopt == 3)): if (binopt == 2): nmu = nwedge else: nmu = 10 pkmugal,pkmuerrgal,pkmucongal = pktools.pkpoletopkmu(nmu,pk0gal,pk2gal,pk4gal,pk0errgal,pk2errgal,pk4errgal,pk0congal,pk2congal,pk4congal) pkmudens,pkmuerrdens,pkmucondens = pktools.pkpoletopkmu(nmu,pk0dens,pk2dens,pk4dens,pk0errdens,pk2errdens,pk4errdens,pk0condens,pk2condens,pk4condens) pkmucross,pkmuerrcross,pkmuconcross = pktools.pkpoletopkmu(nmu,pk0cross,pk2cross,pk4cross,pk0errcross,pk2errcross,pk4errcross,pk0concross,pk2concross,pk4concross) if (binopt == 3): pk2dgal,pk2derrgal,pk2dcongal = pktools.pkmutopk2(kmin2,kmax2,nk2d,kmin,kmax,nkbin,nmu,pkmugal,pkmuerrgal,pkmucongal) pk2ddens,pk2derrdens,pk2dcondens = pktools.pkmutopk2(kmin2,kmax2,nk2d,kmin,kmax,nkbin,nmu,pkmudens,pkmuerrdens,pkmucondens) pk2dcross,pk2derrcross,pk2dconcross = pktools.pkmutopk2(kmin2,kmax2,nk2d,kmin,kmax,nkbin,nmu,pkmucross,pkmuerrcross,pkmuconcross) ######################################################################## # Plot power spectra. # ######################################################################## ncase = 3 labelcase = ['$P_{gg}$','$P_{TT}$','$P_{gT}$'] if (binopt == 1): pk0case,pk0errcase,pk0concase,pk2case,pk2errcase,pk2concase,pk4case,pk4errcase,pk4concase = np.empty((ncase,nkbin)),np.empty((ncase,nkbin)),np.empty((ncase,nkbin)),np.empty((ncase,nkbin)),np.empty((ncase,nkbin)),np.empty((ncase,nkbin)),np.empty((ncase,nkbin)),np.empty((ncase,nkbin)),np.empty((ncase,nkbin)) pk0case[0,:],pk0errcase[0,:],pk0concase[0,:] = pk0gal,pk0errgal,pk0congal pk2case[0,:],pk2errcase[0,:],pk2concase[0,:] = pk2gal,pk2errgal,pk2congal pk4case[0,:],pk4errcase[0,:],pk4concase[0,:] = pk4gal,pk4errgal,pk4congal pk0case[1,:],pk0errcase[1,:],pk0concase[1,:] = pk0dens,pk0errdens,pk0condens pk2case[1,:],pk2errcase[1,:],pk2concase[1,:] = pk2dens,pk2errdens,pk2condens pk4case[1,:],pk4errcase[1,:],pk4concase[1,:] = pk4dens,pk4errdens,pk4condens pk0case[2,:],pk0errcase[2,:],pk0concase[2,:] = pk0cross,pk0errcross,pk0concross pk2case[2,:],pk2errcase[2,:],pk2concase[2,:] = pk2cross,pk2errcross,pk2concross pk4case[2,:],pk4errcase[2,:],pk4concase[2,:] = pk4cross,pk4errcross,pk4concross pktools.plotpkpole(kmin,kmax,nkbin,pk0case,pk0errcase,pk0concase,pk2case,pk2errcase,pk2concase,pk4case,pk4errcase,pk4concase,labelcase) elif (binopt == 2): pkmucase,pkmuerrcase,pkmuconcase = np.empty((ncase,nkbin,nwedge)),np.empty((ncase,nkbin,nwedge)),np.empty((ncase,nkbin,nwedge)) pkmucase[0,:,:],pkmuerrcase[0,:,:],pkmuconcase[0,:,:] = pkmugal,pkmuerrgal,pkmucongal pkmucase[1,:,:],pkmuerrcase[1,:,:],pkmuconcase[1,:,:] = pkmudens,pkmuerrdens,pkmucondens pkmucase[2,:,:],pkmuerrcase[2,:,:],pkmuconcase[2,:,:] = pkmucross,pkmuerrcross,pkmuconcross pktools.plotpkwedge(nwedge,kmin,kmax,nkbin,pkmucase,pkmuerrcase,pkmuconcase,labelcase) elif (binopt == 3): pk2dcase,pk2derrcase,pk2dconcase = np.empty((ncase,nk2d,nk2d)),np.empty((ncase,nk2d,nk2d)),np.empty((ncase,nk2d,nk2d)) pk2dcase[0,:,:],pk2derrcase[0,:,:],pk2dconcase[0,:,:] = pk2dgal,pk2derrgal,pk2dcongal pk2dcase[1,:,:],pk2derrcase[1,:,:],pk2dconcase[1,:,:] = pk2ddens,pk2derrdens,pk2dcondens pk2dcase[2,:,:],pk2derrcase[2,:,:],pk2dconcase[2,:,:] = pk2dcross,pk2derrcross,pk2dconcross pktools.plotpk2d(kmin2,kmax2,nk2d,pk2dcase,pk2derrcase,pk2dconcase,labelcase) return
hz = cosmo.H( boxRedshift ).value / 100. # m sigma relation using the sigma8 corrected power spectrum m2sigma = interp1d(hf.M, hf.sigma ) # m nu relation: nu = (delta_c / sigma_m)**2 m2nu = interp1d(hf.M, hf.nu ) # jacobian toderive = interp1d(n.log(hf.M), n.log(hf.sigma)) mass=hf.M[100:-100] dlnsigmadlnm = derivative(toderive, n.log(mass) ) # in units (Msun/h) / (Mpc/h)**3 ftC16 = f_BH(hf.sigma[100:-100], 0.279, 0.908, 0.671, 1.737) rhom_units = cosmo.Om(boxRedshift)*cosmo.critical_density(boxRedshift).to(u.solMass/(u.Mpc)**3.)#/(cosmo.h)**2. rhom = rhom_units.value # hf.mean_density#/(hz)**2. MF_MD = interp1d(mass, ftC16*rhom*abs(dlnsigmadlnm)/mass) NpartMin = 50. p_init = (-1.85, 7., -2.3, 4.) mp04 = n.log10(NpartMin*9.63 * 10**7) mp10 = n.log10(NpartMin*1.51 * 10**9) mp25 = n.log10(NpartMin*2.359 * 10**10) mp40 = n.log10(NpartMin*9.6 * 10**10. ) # fitting function