def redshift():
"""
Evolution with redshift of matter power spectrum
"""
zs = M.arange(0.,5.,2.)
for z in zs:
print z
c = pt.Camb(hubble = 70., ombh2 = 0.05*(0.7)**2, omch2 = 0.25*(0.7)**2,transfer_redshift = [z])
c.run()
ps = pt.PowerSpectrum(c.cp)
c.kextend(-10,60) #To ensure accurate sigma(r) -- if it doesn't, a warning will ensue
pt.normalizePk(c,0.8*ps.d1(z)/ps.d1(0.)) #sigma_8 at redshift z
#Sheth-Tormen
h = halo.HaloModel(c,st_big_a = 0., st_little_a=0.707, stq = 0.3, k = 10**M.arange(-2,2.01,0.2),massdivsperdex=5)
h.pmm = halo.getHaloPknl(c,h)
M.loglog(h.k, h.pmm, label='z='+str(z))
M.loglog(h.k, h.pk,'k:',label='linear')
cp_halofit = c.cp
cp_halofit['do_nonlinear'] = 1 # Halofit (Smith et al) fit
chalofit = pt.Camb(cambParam=cp_halofit)
chalofit.run()
wheretoplot = N.where(chalofit.k > 1e-2)[0]
M.loglog(chalofit.k[wheretoplot[::10]],chalofit.pk[wheretoplot[::10]],'--',label='halofit')
M.legend()
M.show()
def getInfoCurve():
"""
Various functions to calculate example parameter error bars as in
Neyrinck & Szapudi 2007, MNRAS 375, L51
"""
c = pt.Camb(hubble = 70., ombh2 = 0.05*(0.7)**2, omch2 = 0.25*(0.7)**2)
c.run()
c.kextend(-10,60) # necessary to make sigma(m) integral converge well.
pt.normalizePk(c,0.8) #sigma_8
outputdir = 'example/'
#Sheth-Tormen
h = halo.HaloModel(c,st_big_a = 0., st_little_a=0.707, stq = 0.3, k = 10.**M.arange(-2,1.01,0.25),massdivsperdex=5)
#For final calculations, should use more massdivsperdex, e.g. 20 (maybe 10 is ok)
#also, k is really coarse, as you'll see if you run this.
# get covariance matrix from halo-model trispectrum (saves it in the 'prefix' directory)
# it also automatically runs halo.getHaloPknl
halo.getHaloCov(outputdir,c,h)
# power spectrum at h.k (range of k at which halo model quantities are evaluated)
M.loglog(h.k,h.pnl)
M.show()
# get derivs wrt ln A, tilt
h.dloga = halo.getdlogPnldCosmoParam(c,h,'scalar_amp',linlog='log')
h.dtilt = halo.getdlogPnldCosmoParam(c,h,'scalar_spectral_index',linlog='lin')
M.loglog(h.k,h.dloga**2,label='ln A')
M.loglog(h.k,h.dtilt**2,label='tilt')
M.legend()
M.show()
M.save(outputdir+'dlogpnldloga.dat',M.transpose([h.k,h.dloga]),fmt='%6.5e')
M.save(outputdir+'dlogpnldtilt.dat',M.transpose([h.k,h.dtilt]),fmt='%6.5e')
# get parameter covariance matrix (just a function of k, since there's only one variable)
k, covmat = info.getParamCovMat(outputdir,dlogfilenames=['dlogpnldloga.dat','dlogpnldtilt.dat'])
# plot the unmarginalized error bars in ln A and the tilt,
# if the matter power spectrum is analyzed from k= k[0] to k.
M.loglog(k, M.sqrt(covmat[0,0,:]),label='ln A')
M.loglog(k, M.sqrt(covmat[1,1,:]),label='tilt')
M.legend()
M.show()
def hod():
"""
Displays various galaxy power spectra w/ different HOD's.
See param.py for explanations of hod params.
camb needs to be in ../CAMB by default, but that can be changed in pt.py
"""
c = pt.Camb(hubble = 70., ombh2 = 0.05*(0.7)**2, omch2 = 0.25*(0.7)**2) #may want to go out to transfer_kmax=100 for high accuracy
c.run()
pt.normalizePk(c,0.8) #sigma_8
c.kextend(-10,60) #needed so that sigma(r) integral converges for a wide range of r
#Sheth-Tormen
h = halo.HaloModel(c,st_big_a = 0., st_little_a=0.707, stq = 0.3, k = 10**M.arange(-2,2.,0.1),massdivsperdex=5)
h.pmm = halo.getHaloPknl(c,h)
h.p.whichp='gg' # by default, h.p.whichp = 'mm', returning the matter power spectrum
# by default, h.p.k_mmin_msun = 1e11, h.p,k_betas = 1
mmins = 10.**M.arange(10.,12.01,0.2)
for i in range(len(mmins)):
h.p.k_mmin_msun = mmins[i]
h.refreshHOD(c)
h.pgg = halo.getHaloPknl(c,h)
M.loglog(h.k,h.pgg,'y')
M.loglog(h.k,h.pk,'k')
M.loglog(h.k,h.pmm,'b')
M.show()
betas = M.arange(0.5,1.5,0.1)
h.p.k_mmin_msun = 1e11
for i in range(len(betas)):
h.p.k_betas = betas[i]
h.refreshHOD(c)
h.pgg = halo.getHaloPknl(c,h)
M.loglog(h.k,h.pgg,'y')
M.loglog(h.k,h.pk,'k')
M.loglog(h.k,h.pmm,'b')
M.show()
def generate(c=None,d=None,dk=None,ng=64,boxsize=128.,sigma8=0.829, sigmaalpt = 10.,scheme='muscle',largescale=None,smallscale=None,exactpk=False, seed = 42389,returnfft = False, dopbc=True, fileroot=None, returnpos=True, returndisp = False, plottest=False, returninitdens=False, justreturnc = False, returnvel=False,deltaz4vel=1./128., hubble=67.77, ombh2 = 0.048252*0.6777**2, omch2 = (0.30712-0.048252)*0.6777**2, redshift = 0.,kmax=30.,omk=0.):
"""
possible inputs:
c = Camb instance; contains cosmological parameters, power spectrum
d = configuration-space density field
dk = FFT of a density field
parameters:
sigmaalpt = Gaussian k-space interpolation smoothing scale, as in ALPT
scheme: can be 'zeld'ovich, '2lpt', 'sc' (single-scale spherical collapse), 'muscle' (multiscale)
largescale/smallscale: use for scale interpolation
dopbc: False to preserve distortion of particle lattice, not enforcing periodic boundary conditions
returnpos, returndisp, returnvel: return position, displacement field at particles, velocities [velocities only work for Zeld, 2LPT currently!]
plottest: show a slice of the particles
exactpk: Set each Fourier amplitude exactly to the linear power spectrum,
suppressing fluctuations in Fourier amplitudes
"""
if (returnpos & returndisp):
print 'Choose either position or displacement field to return'
return
if returnvel:
omegam = (ombh2+omch2)/(hubble/100.)**2
omegal = 1.-omk-omegam
hubble_z = 100.*N.sqrt(omegam*(1.+redshift)**3 + omk*(1+redshift)**2 + omegal)
# Valid only for simple dark energy; doesn't allow w != -1
if ((((c == None) | (returnvel & (smallscale != None))) &
((d == None) & (dk == None))) | (justreturnc == True)):
print 'c == None:', (c == None)
print 'returnvel = ', returnvel
c = pt.Camb(hubble=hubble, ombh2 = ombh2, omch2 = omch2,omk=omk,
transfer_kmax=kmax,transfer_redshift=[0.])
if (dk == None):
c.run()
sigma82default_z0 = pt.normalizePk(c,sigma8)
if redshift != 0.:
c = pt.Camb(hubble=hubble, ombh2 = ombh2, omch2 = omch2,omk=omk,
transfer_kmax=kmax,transfer_redshift=[redshift])
c.run()
c.pk *= sigma8**2/sigma82default_z0
c.logpk = N.log(c.pk)
c.pkSplineCoeff = SS.cspline1d(c.logpk)
if justreturnc:
return c
if (returnvel & (smallscale != None)):
print 'Numerically computing velocity'
cplusdeltaz = pt.Camb(hubble=hubble, ombh2 = ombh2, omch2 = omch2, omk=omk,
transfer_kmax=kmax,transfer_redshift=[redshift+deltaz4vel])
cplusdeltaz.run()
cplusdeltaz.pk *= sigma8**2/sigma82default_z0
cplusdeltaz.logpk = N.log(cplusdeltaz.pk)
growthindeltaz=N.mean(c.logpk-cplusdeltaz.logpk)
print 'camb:', growthindeltaz
print 'naive:',2.*N.log(getgrowth(c,z=redshift)/getgrowth(c,z=redshift+deltaz4vel))
noiselevel = N.std(c.logpk-cplusdeltaz.logpk)
print 'std/mean(growth from camb)=',noiselevel/growthindeltaz
if (noiselevel/growthindeltaz > 1./8.):
print "Warning! deltaz so small that it's giving lots of noise."
cplusdeltaz.pk = c.pk * N.exp(growthindeltaz)
cplusdeltaz.logpk = c.logpk + growthindeltaz
cplusdeltaz.pkSplineCoeff = SS.cspline1d(cplusdeltaz.logpk)
#The Hubble parameter at z=redshift
dispplusdeltaz = generate(c=cplusdeltaz,ng=ng,boxsize=boxsize,sigmaalpt = sigmaalpt,
largescale=largescale,smallscale=smallscale, seed = seed,
dopbc=dopbc, fileroot=fileroot, returnpos=False, returndisp=True,
plottest=False, returnvel=False,exactpk=exactpk)
# the Zel'dovich displacement-divergence in Fourier space
if d == None:
if dk == None:
kgrid = getkgrid(ng=ng,boxsize=boxsize,whattoget='k')
dk=makegauss(c,kgrid,boxsize=boxsize,exactpk=exactpk,returnfft=True,seed=seed)
if returnfft:
return dk
else:
#(over)write ng
ng=dk.shape[0]
d = N.fft.irfftn(dk)
else: #shouldn't have both d and dk non-None
print 'd supplied'
ng = d.shape[0]
kgrid = getkgrid(ng=ng,boxsize=boxsize,whattoget='k')
dk = N.fft.rfftn(d)
if ((scheme != None) & ((smallscale != None) | (largescale != None))):
print "Please specify only 'scheme' or ('smallscale' and 'largescale')"
if (smallscale == None) & (largescale == None):
if (scheme != None):
largescale = scheme
else:
print "Please specify either a full 'scheme' or "
print "a 'smallscale' and 'largescale' displacement field scheme."
return
print 'largescale=',largescale
if smallscale == 'sc':
psismall = N.fft.rfftn(sc(-d))
elif smallscale == 'muscle':
psismall = N.fft.rfftn(muscle(-d))
elif smallscale == 'zeld':
psismall = -dk
if largescale == 'zeld':
psilarge = -dk
elif largescale == '2lpt':
psiquadratic = N.fft.rfftn(twolpt(-dk,boxsize=boxsize))
psilarge = psiquadratic - dk
# dk because we didn't add it in twolpt for efficiency reasons
elif largescale == 'sc':
psilarge = N.fft.rfftn(sc(-d))
elif largescale == 'muscle':
psilarge = N.fft.rfftn(muscle(-d))
if (smallscale != None) & (largescale != None):
psik = scalegaussinterp(psilarge,psismall,kgrid,sigma=sigmaalpt)
elif smallscale != None:
psik = psismall
elif largescale != None:
psik = psilarge
disp = invdiv(dk=psik,boxsize=boxsize,dopsi2pos=False).reshape(ng,ng,ng,3)
pos = psi2pos(disp,boxsize=boxsize,dopbc=dopbc)
if returnvel: # only works for Zeld, 2LPT
time = 1./(1.+redshift)
print 'time, hubble_z, f_omega = ',time,hubble_z,f_omega(c,time)
vel = disp * time *hubble_z * f_omega(c,time)
print 'total factor = ',time*hubble_z*f_omega(c,time)
print 'factor in gadget = ',N.sqrt(time)*hubble_z*f_omega(c,time)
if scheme == '2lpt':
vel += 3./7. * time * hubble_z * f2_omega(c,time)* \
invdiv(dk=psiquadratic,boxsize=boxsize,dopsi2pos=False)#.swapaxes(0,2)
if plottest:
if fileroot == None:
fileroot='plottest'
plotslice(pos,filename=fileroot+'.png',boxsize=boxsize)
if returndisp:
return disp
if (returninitdens & (returnpos == False) & (returnvel == False)):
return d
if (returnpos & returnvel & (returninitdens == False)):
return pos,vel
if (returnpos & returninitdens & (returnvel == False)):
return pos,d
if (returnpos & returnvel & returninitdens):
return pos,vel,d
if returnpos:
return pos
if returnvel:
return vel
return
def getdlogPnldCosmoParam(c,h,paramstring,epsilon = 2.**(-6),linlog='log',sig8 = 0.,usepnl=True, usehalofit=False):
"""
Returns dlog(Pnl(k))/d(parameter)
linlog: if 'lin' (or anything but 'log'), do dlogP/dparam; if 'log', do dlogP/dlogparam
epsilon = interval in param or log param
Warning; this keeps the scalar amplitude A constant, not sigma_8.
To keep sigma_8 constant, set sig8 to be nonzero.
To get linear power spectrum dlog's, set usepnl = False
Should use Smith et al. HALOFIT power spectrum if usepnl=False, usehalofit=True (though this hasn't been tested).
"""
cp = copy.copy(c.cp)
if (usehalofit):
cp['do_nonlinear'] = 1
if linlog == 'log':
multfact = M.exp(epsilon)
divfact = M.exp(-epsilon)
else:
multfact = 1. + epsilon
divfact = 1. - epsilon
if (paramstring == 'barf'):
ommh2 = cp['ombh2']+cp['omch2']
cp['ombh2'] *= multfact
cp['omch2'] = ommh2 - cp['ombh2']
elif isinstance(cp[paramstring],float):
cp[paramstring] *= multfact
else:
for i in range(len(cp[paramstring])):
cp[paramstring][i] *= multfact
cplus = pt.Camb(cambParam = cp)
cplus.run()
if (paramstring == 'barf'):
cp['ombh2'] *= divfact/multfact #since we're starting from the cplus params
cp['omch2'] = ommh2 - cp['ombh2']
elif isinstance(cp[paramstring],float):
cp[paramstring] *= multfact
else:
for i in range(len(cp[paramstring])):
cp[paramstring][i] *= divfact/multfact #since we're starting from the cplus params
cminus = pt.Camb(cambParam = cp)
cminus.run()
cplus.kextend(-10,60)
cminus.kextend(-10,60)
if (sig8 > 0.):
pt.normalizePk(cplus,sig8)
pt.normalizePk(cminus,sig8)
if (usepnl):
hplus = HaloModel(cplus,haloModelParam = h.p)
hplus.pknl = getHaloPknl(cplus,hplus)
hminus = HaloModel(cminus,haloModelParam = h.p)
hminus.pknl = getHaloPknl(cminus,hminus)
else:
hplus = copy.deepcopy(h)
hplus.pknl = cplus.pkInterp(h.k)
hminus = copy.deepcopy(h)
hminus.pknl = cminus.pkInterp(h.k)
dlog = M.log(hplus.pknl/hminus.pknl)/(2.*epsilon)
#M.loglog(h.k,hplus.pknl)
#M.loglog(h.k,hminus.pknl)
#M.show()
return dlog
