def lnlike(H0, z, zerr, pb_gal, distmu, diststd, distnorm, H0_min, H0_max,
z_min, z_max, zerr_use, cosmo_use):
if ((zerr_use == False) & (cosmo_use == False)):
distgal = (c / 1000.) * z / H0
like_gals = pb_gal * distnorm * norm(distmu,
diststd).pdf(distgal) * z**2
normalization = H0**3
elif ((zerr_use == False) & (cosmo_use == True)):
cosmo = FlatLambdaCDM(H0=H0, Om0=0.3, Tcmb0=2.725)
distgal = cosmo.luminosity_distance(z).value #in Mpc
#like_gals = pb_gal * distnorm * norm(distmu, diststd).pdf(distgal)*distgal**2/cosmo.H(z).value
like_gals = pb_gal * distnorm * norm(distmu, diststd).pdf(
distgal) * distgal * distgal * (cosmo.comoving_distance(z).value +
(1. + z) / cosmo.H(z).value)
normalization = 1.
elif ((zerr_use == True) & (cosmo_use == False)):
ngals = z.shape[0]
like_gals = np.zeros(ngals)
z_s = np.arange(z_min, z_max, step=0.02)
const = (c / 1000.) / H0
normalization = H0**3
for i in range(ngals):
# Multiply the 2 Gaussians (redshift pdf and GW likelihood) with a change of variables into one Gaussian with mean Mu_new and std sigma_new
#mu_new = (z[i]*diststd[i]*diststd[i]/(const*const)+ distmu[i]/const*zerr[i])/(diststd[i]*diststd[i]/(const*const)+zerr[i]*zerr[i])
#sigma_new = (diststd[i]*diststd[i]*zerr[i]*zerr[i]/(const*const)/(diststd[i]*diststd[i]/(const*const)+ zerr[i]*zerr[i]))**0.5
#like_gals[i]= pb_gal[i] * distnorm[i] * romb(gauss(mu_new, sigma_new, z_s) * z[i]*z[i], dx=0.02)
like_gals[i] = pb_gal[i] * distnorm[i] * romb(
gauss(z[i], zerr[i], z_s) *
gauss(distmu[i], diststd[i], const * z_s) * z[i] * z[i],
dx=0.02)
else:
ngals = z.shape[0]
cosmo = FlatLambdaCDM(H0=H0, Om0=0.3, Tcmb0=2.725)
like_gals = np.zeros(ngals)
z_s = np.arange(z_min, z_max, step=0.02)
normalization = 1.
for i in range(ngals):
dist_gal = cosmo.luminosity_distance(z[i]).value
like_gals[i] = pb_gal[i] * distnorm[i] * romb(
gauss(z[i], zerr[i], z_s) *
gauss(distmu[i], diststd[i], dist_gal) * dist_gal * dist_gal /
cosmo.H(z[i]).value,
dx=0.02)
lnlike_sum = np.log(np.sum(like_gals) / normalization)
return lnlike_sum
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 calc_ps2d(cube, fmin=154, fmax=162, fov=2):
f21cm = 1420.405751 # [MHz]
cosmo = FlatLambdaCDM(H0=71, Om0=0.27)
nf, ny, nx = cube.shape
fc = (fmin + fmax) / 2
zc = f21cm / fc - 1
DM = cosmo.comoving_transverse_distance(zc).value # [Mpc]
pixelsize = fov / nx # [deg]
d_xy = DM * np.deg2rad(pixelsize) # [Mpc]
fs_xy = 1 / d_xy # [Mpc^-1]
dfreq = (fmax - fmin) / (nf-1) # [MHz]
c = ac.c.to("km/s").value
H = cosmo.H(zc).value # [km/s/Mpc]
d_z = c * (1+zc)**2 * dfreq / H / f21cm # [Mpc]
fs_z = 1 / d_z # [Mpc^-1]
cubefft = fftpack.fftshift(fftpack.fftn(cube))
ps3d = np.abs(cubefft) ** 2 # [K^2]
norm1 = 1 / (nx * ny * nf)
norm2 = 1 / (fs_xy**2 * fs_z) # [Mpc^3]
norm3 = 1 / (2*np.pi)**3
ps3d *= (norm1 * norm2 * norm3) # [K^2 Mpc^3]
k_xy = 2*np.pi * fftpack.fftshift(fftpack.fftfreq(nx, d=d_xy))
k_z = 2*np.pi * fftpack.fftshift(fftpack.fftfreq(nf, d=d_z))
k_perp = k_xy[k_xy >= 0]
k_los = k_z [k_z >= 0]
n_k_perp = len(k_perp)
n_k_los = len(k_los)
ps2d = np.zeros(shape=(n_k_los, n_k_perp))
eps = 1e-8
ic_xy = (np.abs(k_xy) < eps).nonzero()[0][0]
ic_z = (np.abs(k_z) < eps).nonzero()[0][0]
p_xy = np.arange(nx) - ic_xy
p_z = np.abs(np.arange(nf) - ic_z)
mx, my = np.meshgrid(p_xy, p_xy)
rho = np.sqrt(mx**2 + my**2)
rho = np.around(rho).astype(int)
for r in range(n_k_perp):
ix, iy = (rho == r).nonzero()
for s in range(n_k_los):
iz = (p_z == s).nonzero()[0]
cells = np.concatenate([ps3d[z, iy, ix] for z in iz])
ps2d[s, r] = cells.mean()
return (ps2d, k_perp, k_los)
class cosmology(object): #{{{
# some fundamental constants
c0 = 2.99792458e5 # km/s
GN = 4.30091e-9 # Mpc/Msun*(km/s)**2
delta_c = 1.686
hPl = 6.62607004e-34 # SI
kBoltzmann = 1.38064852e-23 # SI
def __init__(self, cosmo_dict={None}): #{{{
print(cosmo_dict)
# basic cosmology parameters
self.h = _set_param(cosmo_dict, 'h', 0.7)
self.Om = _set_param(cosmo_dict, 'Om0', 0.3)
self.Ob = _set_param(cosmo_dict, 'Ob0', 0.046)
self.As = _set_param(cosmo_dict, 'As', 2.1e-9)
self.pivot_scalar = _set_param(cosmo_dict, 'pivot_scalar',
0.05 / self.h)
self.w = _set_param(cosmo_dict, 'w', -1)
self.ns = _set_param(cosmo_dict, 'ns', 0.97)
self.Mnu = _set_param(cosmo_dict, 'Mnu', 0.)
self.Neff = _set_param(cosmo_dict, 'Neff', 0.)
self.TCMB = _set_param(cosmo_dict, 'TCMB', 2.726)
self.P0 = _set_param(cosmo_dict, 'pressure_profile_P0', 18.1)
# various definitions, should hopefully not need much change
self.mass_def_initial = _set_param(cosmo_dict, 'mass_def_initial',
'200m')
self.mass_def_kappa_profile = _set_param(cosmo_dict,
'mass_def_profile', 'vir')
self.mass_def_Tinker = _set_param(cosmo_dict, 'mass_def_Tinker',
'200m')
self.mass_def_Batt = _set_param(cosmo_dict, 'mass_def_Batt', '200c')
self.r_out_def = _set_param(cosmo_dict, 'r_out_def', 'vir')
self.r_out_scale = _set_param(cosmo_dict, 'r_out_scale', 2.5)
self.concentration_model = _set_param(cosmo_dict,
'concentration_model', 'duffy08')
self.halo_profile = _set_param(cosmo_dict, 'halo_profile', 'nfw')
self.HMF_fuction = _set_param(cosmo_dict, 'HMF_function', 'Tinker10')
# derived quantities
self.OL = 1. - self.Om # dark energy
self.Oc = self.Om - self.Ob # (cold) dark matter
self.H0 = 100. * self.h
self.rhoM = self.Om * 2.7753e11
self.bias_arr = None
self.hmf_arr = None
self.my_angular_diameter_distance = None
self.my_angular_diameter_distance_z1z2 = None
self.my_H = None
self.my_comoving_distance = None
self.astropy_cosmo = None
self.initialized_colossus = False
self.my_D = None
self.my_k_integral = None
self.my_PK = None
self.my_PK_psi = None
self.sigma8 = None
#}}}
def __initialize_astropy(self): #{{{
# adds an astropy object
print 'Initializing astropy.'
self.astropy_cosmo = FlatLambdaCDM(H0=self.H0 * u.km / u.s / u.Mpc,
Tcmb0=self.TCMB * u.K,
Om0=self.Om,
Neff=self.Neff,
m_nu=self.Mnu * u.eV,
Ob0=self.Ob,
name='my cosmology')
@property
def angular_diameter_distance(self):
if self.astropy_cosmo is None:
self.__initialize_astropy()
if self.my_angular_diameter_distance is None:
self.my_angular_diameter_distance = lambda z: (
self.astropy_cosmo.angular_diameter_distance(z)).value * self.h
return self.my_angular_diameter_distance
@property
def angular_diameter_distance_z1z2(self):
if self.astropy_cosmo is None:
self.__initialize_astropy()
if self.my_angular_diameter_distance_z1z2 is None:
self.my_angular_diameter_distance_z1z2 = lambda z1, z2: (
self.astropy_cosmo.angular_diameter_distance_z1z2(
z1, z2)).value * self.h
return self.my_angular_diameter_distance_z1z2
@property
def H(self):
if self.astropy_cosmo is None:
self.__initialize_astropy()
if self.my_H is None:
self.my_H = lambda z: (self.astropy_cosmo.H(z)).value / self.h
return self.my_H
@property
def comoving_distance(self):
if self.astropy_cosmo is None:
self.__initialize_astropy()
if self.my_comoving_distance is None:
self.my_comoving_distance = lambda z: (
self.astropy_cosmo.comoving_distance(z)).value * self.h
return self.my_comoving_distance
#}}}
def __initialize_CAMB(self): #{{{
# adds linear matter power interpolator
print 'Initializing CAMB.'
pars = camb.CAMBparams()
pars.set_cosmology(H0=self.H0,
ombh2=self.Ob * self.h**2.,
omch2=self.Oc * self.h**2.,
omk=0.,
mnu=self.Mnu,
standard_neutrino_neff=self.Neff,
nnu=self.Neff,
TCMB=self.TCMB)
pars.InitPower.set_params(ns=self.ns,
As=self.As,
pivot_scalar=self.pivot_scalar)
pars.NonLinear = model.NonLinear_none
# print(pars)
self.my_PK = get_matter_power_interpolator(pars,
zmin=0.,
zmax=6.,
nz_step=150,
kmax=101.,
nonlinear=False,
hubble_units=True,
k_hunit=True).P
pars.set_matter_power(redshifts=[0.], kmax=20.)
results = camb.get_results(pars)
self.sigma8 = results.get_sigma8()[0]
print 'sigma8 = ' + str(self.sigma8)
def PK(self, z, k):
if self.my_PK is None:
self.__initialize_CAMB()
return self.my_PK(z, k)
def __initialize_nonlin_CAMB(self):
print 'Initializing nonlinear CAMB.'
parsnl = camb.CAMBparams()
parsnl.set_cosmology(H0=self.H0,
ombh2=self.Ob * self.h**2.,
omch2=self.Oc * self.h**2.,
omk=0.,
mnu=self.Mnu,
standard_neutrino_neff=self.Neff,
nnu=self.Neff,
TCMB=self.TCMB)
parsnl.InitPower.set_params(ns=self.ns,
As=self.As,
pivot_scalar=self.pivot_scalar)
# parsnl.NonLinear = model.NonLinear_both
parsnl.set_matter_power(redshifts=[0.], kmax=101.)
self.my_PK_psi = get_matter_power_interpolator(
parsnl,
zmin=0.,
zmax=1100.,
nz_step=150,
kmax=101.,
nonlinear=True,
hubble_units=True,
k_hunit=True,
var1=model.Transfer_Weyl,
var2=model.Transfer_Weyl).P
def PK_psi(self, z, k):
if self.my_PK_psi is None:
self.__initialize_nonlin_CAMB()
return self.my_PK_psi(z, k)
def D(self, z):
if self.my_PK is None:
self.__initialize_CAMB()
if self.my_D is None:
self.my_D = lambda z: np.sqrt(
self.PK(z, 0.01) / self.PK(0., 0.01)) # growth function
return self.my_D(z)
def k_integral(self):
if self.my_PK is None:
self.__initialize_CAMB()
if self.my_k_integral is None:
integrand = lambda k: (1. / (2. * np.pi)) * k * self.PK(0., k)
self.my_k_integral, _ = quad(integrand, 1.e-10, 100., limit=100)
return self.my_k_integral
#}}}
def _initialize_colossus(self): #{{{
# adds colossus object
print 'Initializing Colossus.'
if self.sigma8 is None:
self.__initialize_CAMB()
colossus_cosmology.setCosmology(
'my cosmology', {
'flat': True,
'H0': self.H0,
'Om0': self.Om,
'Ob0': self.Ob,
'sigma8': self.sigma8,
'ns': self.ns,
'de_model': 'w0',
'w0': self.w,
'Tcmb0': self.TCMB,
'Neff': self.Neff
})
self.initialized_colossus = True
#}}}
def virial_radius(self, M, z, massdef): #{{{
if not self.initialized_colossus:
self._initialize_colossus()
_, rvir, _ = mass_adv.changeMassDefinitionCModel(
M,
z,
massdef,
'vir',
profile=self.halo_profile,
c_model=self.concentration_model)
return rvir * 1e-3 # Mpc/h
#}}}
def virial_radius_small_masses(self, M, z, massdef): #{{{
if not self.initialized_colossus:
self._initialize_colossus()
_, rvir, _ = mass_adv.changeMassDefinitionCModel(
M,
z,
massdef,
'vir',
profile=self.halo_profile,
c_model=self.small_mass_concentration_model)
return rvir * 1e-3 # Mpc/h
#}}}
def convert_mass(self, M, z, massdefin, massdefout): #{{{
if massdefin == massdefout:
return M
if not self.initialized_colossus:
self._initialize_colossus()
Mout, _, _ = mass_adv.changeMassDefinitionCModel(
M,
z,
massdefin,
massdefout,
profile=self.halo_profile,
c_model=self.concentration_model)
return Mout
#}}}
@staticmethod
@jit(nopython=True)
def __hmf_Tinker2010(nu, z): #{{{
# Eq 8 of Tinker10, parameters from Table 4
z1 = z
if z1 > 3.: z1 = 3
# HMF only calibrated below z = 3, use the value for z = 3 at higher redshifts
beta = 0.589 * (1. + z1)**(0.20)
phi = -0.729 * (1. + z1)**(-0.08)
eta = -0.243 * (1. + z1)**(0.27)
gamma = 0.864 * (1. + z1)**(-0.01)
alpha = 0.368
return alpha * (1. +
(beta * nu)**(-2. * phi)) * nu**(2. * eta) * np.exp(
-0.5 * gamma * nu**2)
#}}}
@staticmethod
@jit(nopython=True)
def __hmf_Tinker2008(sigma): #{{{
B = 0.482
d = 1.97
e = 1.
f = 0.51
g = 1.228
return B * ((sigma / e)**(-d) + sigma**(-f)) * np.exp(-g / sigma**2.)
#}}}
@staticmethod
@jit(nopython=True)
def __hmf_ShethTormen(nu): #{{{
A = 0.3222
a = 0.707
p = 0.3
return A * (2. * a / np.pi)**0.5 * nu * (1. +
(nu**2. / a)**p) * np.exp(
-a * nu**2. / 2.)
#}}}
@staticmethod
@jit(nopython=True)
def __bz_Tinker2010(nu): #{{{
# Eq 6 of Tinker10, with parameters from Table 2
Delta = 200.
y = np.log10(Delta)
A = 1.0 + 0.24 * y * np.exp(-(4. / y)**4)
a = 0.44 * y - 0.88
B = 0.183
b = 1.5
C = 0.019 + 0.107 * y + 0.19 * np.exp(-(4. / y)**4)
c = 2.4
return 1. - A * nu**a / (nu**a + 1.686**a) + B * nu**b + C * nu**c
#}}}
@staticmethod
@jit(nopython=True)
def __window_function_FT(x): #{{{
return 3. * (np.sin(x) - x * np.cos(x)) / x**3.
#}}}
@staticmethod
def __chi(x): #{{{
return ((x**2 - 3.) * np.sin(x) + 3. * x * np.cos(x)) / x**3
#}}}
def __sigma(self, M, z): #{{{
RM = (3. * M / (4. * np.pi * self.rhoM))**(1. / 3.)
integrand = lambda k: (1. / (2. * np.pi**2)) * (k**2 * self.PK(
z, k) * (cosmology.__window_function_FT(k * RM))**2)
sigmasq, _ = quad(integrand, 1e-10, 100., limit=100)
return np.sqrt(sigmasq)
#}}}
def __chi_integral(self, M, z): #{{{
# computes the chi-integral [which is close to the derivative of sigma]
RM = (3. * M / (4. * np.pi * self.rhoM))**(1. / 3.)
integrand = lambda lk: (1. * np.log(10.) / np.pi**2) * (
(10.**
(lk))**3 * self.PK(z, (10.**lk)) * cosmology.__window_function_FT(
(10.**lk) * RM) * cosmology.__chi((10.**lk) * RM))
integral, _ = quad(integrand, -10., 2., limit=100)
return integral
#}}}
def dndM(self, M, z, s, chi_int, HMF_fuction): #{{{
if HMF_fuction is 'Tinker10':
f = cosmology.__hmf_Tinker2010(cosmology.delta_c / s, z)
return -cosmology.delta_c * self.rhoM * f * chi_int / (2. * s**3. *
M**2.)
elif HMF_fuction is 'Tinker08':
g = cosmology.__hmf_Tinker2008(s)
return -self.rhoM * g * chi_int / (2. * s**2. * M**2.)
elif HMF_fuction is 'ShethTormen':
g = cosmology.__hmf_ShethTormen(cosmology.delta_c / s)
return -self.rhoM * g * chi_int / (2. * s**2. * M**2.)
else:
raise RuntimeError('Unknown HMF function in cosmology.dndM')
#}}}
def create_HMF_and_bias(self, path, numerics, pardict={None}): #{{{
if os.path.isfile(path +
'HMF_and_bias.npz') and not numerics.debugging:
raise RuntimeError('HMF_and_bias have already been computed.')
Npoints_M = numerics.Npoints_M
Npoints_z = numerics.Npoints_z
logM_grid = numerics.logM_grid
z_grid = numerics.z_grid
self.hmf_arr = np.empty((Npoints_M, Npoints_z))
self.bias_arr = np.empty((Npoints_M, Npoints_z))
for ii in xrange(Npoints_M):
start = time()
for jj in xrange(Npoints_z):
z = z_grid[jj]
M = self.convert_mass(10.**logM_grid[ii], z,
self.mass_def_initial,
self.mass_def_Tinker)
sigma = self.__sigma(M, z)
chi_int = self.__chi_integral(M, z)
self.hmf_arr[ii, jj] = self.dndM(M, z, sigma, chi_int,
self.HMF_fuction)
self.bias_arr[ii, jj] = cosmology.__bz_Tinker2010(
cosmology.delta_c / sigma)
end = time()
if (ii % 4 == 0) and numerics.verbose:
print str((end - start) / 60. *
(Npoints_M -
ii)) + ' minutes remaining in create_HMF_and_bias.'
np.savez(
path + 'HMF_and_bias.npz',
hmf=self.hmf_arr,
bias=self.bias_arr,
)
'''
Modified GW luminosity distance
'''
cosmo = FlatLambdaCDM(H0=H0, Om0=Om0GLOB)
return (cosmo.luminosity_distance(z).value) * Xi(z, Xi0, n=n)
def Xi(z, Xi0, n):
return Xi0 + (1 - Xi0) / (1 + z)**n
zGridGLOB = np.logspace(start=-10, stop=5, base=10, num=1000)
dLGridGLOB = cosmo70GLOB.luminosity_distance(zGridGLOB).value
dcomGridGLOB = cosmo70GLOB.comoving_distance(zGridGLOB).value
HGridGLOB = cosmo70GLOB.H(zGridGLOB).value
from scipy import interpolate
dcom70fast = interpolate.interp1d(zGridGLOB,
dcomGridGLOB,
kind='cubic',
bounds_error=False,
fill_value=(0, np.NaN),
assume_sorted=True)
dL70fast = interpolate.interp1d(zGridGLOB,
dLGridGLOB,
kind='cubic',
bounds_error=False,
fill_value=(0, np.NaN),
assume_sorted=True)
H70fast = interpolate.interp1d(zGridGLOB,
DictFormatter)
import matplotlib.pyplot as plt
from matplotlib import pyplot, transforms
font = {'family': 'STIXGeneral', 'size': 22}
matplotlib.rc('font', **font)
redshift = 2.0
galfile = 'gal_iz30_atlascat_vel.cat'
x, y, z, vy, loglum = np.loadtxt(galfile, unpack=True)
zc = z < 30
aexp = 1. / (1 + redshift)
Hz = cosmo.H(redshift).value
sz = 1e-2
PlotName = 'sigmax' # zspace # sigmax # real
y_ = y if PlotName == 'real' else y + vy / (aexp * Hz) # zspace
ppname = PlotName
if PlotName == 'sigmax':
ppname = 'zspace_sigmaz%.4f' % sz
pname = '%s_andrea2' % ppname
ym = np.mean(y_[zc])
xm = np.mean(x[zc])
class Cosmos_flat:
def __init__(self, Omega_m0, H0):
self.Omega_m0 = Omega_m0
self.H0 = H0
self.h0 = H0/100
self.H_z = 0
self.cosmos = FlatLambdaCDM(H0, Om0=Omega_m0)
self.nfw_galsim = None
self.nfw_com_dist = None
self.nfw_z = None
self.delta_sigma_coeff_1 = 1662916.5401756007
self.delta_sigma_coeff_2 = 0
self.NFW_rho_profile_delta_c = 0
self.NFW_rho_profile_concentration = 0
self.uni_crit_dens_z = 0
self.density_radius_scale = 0
self.NFW_radius = 0
def com_distance(self, z, h_unit=True):
if h_unit:
hu = self.h0
else:
hu = 1
return self.cosmos.comoving_distance(z).value * hu
def NFW_profile_galsim(self, halo_position, Mass, conc, z, h_unit=True):
"""
:param halo_position: (ra, dec) arcsec
:param Mass:
:param conc:
:param z:
:param h_unit:
:return:
"""
self.nfw_galsim = galsim.NFWHalo(Mass, conc, z, halo_position, self.Omega_m0, 1 - self.Omega_m0)
self.nfw_com_dist = self.com_distance(z, h_unit=h_unit)
self.nfw_z = z
self.delta_sigma_coeff_2 = self.delta_sigma_coeff_1/self.nfw_com_dist/(1 + self.nfw_z)
self.H_z = self.cosmos.H(z)
def NFW_rho_profile(self, log_10_Mass, conc, z, density_radius_scale=200, h_unit=True):
# rho(r) = delta_c*rho_c(z)/(r/r_s)/(1+r/r_s)^2
# H(z)
self.H_z = self.cosmos.H(z)
# to define the halo radius above n*critical_mass_density(z)
self.density_radius_scale = density_radius_scale
# concentration
self.NFW_rho_profile_concentration = conc
# delta_c
self.NFW_rho_profile_delta_c = density_radius_scale*conc**3/3/(numpy.log(1+conc) - conc/(1+conc))
# h_0^2 * M_sum / Mpc^{-3}
self.uni_crit_dens_z = 3*3.085677581/8/numpy.pi/6.67408/1.9885*self.H_z/100
self.nfw_com_dist = self.com_distance(z, h_unit=h_unit)
def get_shear(self, src_ra, src_dec, src_z, reduced=False):
com_dist_src = self.com_distance(src_z)
crit_coeff = self.delta_sigma_coeff_2*com_dist_src / (com_dist_src - self.nfw_com_dist)
gamma1, gamma2 = self.nfw_galsim.getShear((src_ra, src_dec), src_z, reduced=reduced)
delta_sigma = numpy.sqrt(gamma1 ** 2 + gamma2 ** 2) * crit_coeff
return gamma1, gamma2, delta_sigma
def get_kappa(self, ra, dec, z):
return self.nfw_galsim.getConvergence((ra, dec), z)
def get_sigma_crit(self, src_z, h_unit=True):
com_dist_src = self.com_distance(src_z, h_unit)
return self.delta_sigma_coeff_2*com_dist_src / (com_dist_src - self.nfw_com_dist)
def load(self, zMax=0.1, zErrFac=1, comovingNumberDensityGoal=0.1):
if self.verbose:
print('Sampling homogenously distributed galaxies...')
from astropy.cosmology import FlatLambdaCDM
fiducialcosmo = FlatLambdaCDM(H0=70.0, Om0=0.3)
vol = 4 * np.pi * fiducialcosmo.comoving_distance(zMax).value**3 / 3
nGals = np.int(vol * comovingNumberDensityGoal)
dg = pd.DataFrame(columns=[
'', 'theta', 'phi', 'z', 'z_err', 'z_lowerbound', 'z_lower',
'z_upper', 'z_upperbound'
])
dg.loc[:, "theta"] = np.arccos(1 - 2 * np.random.uniform(size=nGals))
dg.loc[:, "phi"] = 2 * np.pi * np.random.uniform(size=nGals)
# the following calculation of redshifts is independent of H0
dmax = fiducialcosmo.comoving_distance(zMax).value
# sample d_com^2 dd_com from 0 to dmax. CDF is p = d^3/dmax^3, quantile func is dmax*(p**(1/3))
ds = dmax * np.random.uniform(size=nGals)**(1. / 3)
z_table = np.linspace(0, zMax, 1000)
d_table = fiducialcosmo.comoving_distance(z_table).value
from scipy import interpolate
redshFromdcom = interpolate.interp1d(d_table, z_table, kind='cubic')
dg.loc[:, "z"] = redshFromdcom(ds)
# remove some galaxies
def compl_of_z(z, steep=5 / zMax, zstar=0.4 * zMax):
return 0.5 * (1 - np.tanh((z - zstar) * steep))
n = 100
zedges = np.linspace(0, zMax, n)
if self.verbose:
print(
'Removing galaxies according to prescribed incompleteness function...'
)
for i, z in enumerate(zedges):
if i == n - 1:
z2 = zMax + 0.0001
else:
z2 = zedges[i + 1]
mask = (dg.theta.to_numpy() < np.pi / 2) & (
dg.z.to_numpy() <= z2) & (dg.z.to_numpy() > z)
nRemove = np.int(
np.sum(mask) * (1 - compl_of_z(z + 0.5 * zMax / n)))
# indices of all relevant galaxies in this volume
idx = np.nonzero(mask)[0]
if nRemove > 0:
# sample nRemove *unique* elements from idx
#import random
#idxidx = random.sample(range(len(idx)), nRemove)
#idxDrop = idx[idxidx]
np.random.shuffle(idx)
idxDrop = set(idx[:nRemove])
# remove them - anecdocially, taking is faster than dropping
idxKeep = set(range(dg.shape[0])) - idxDrop
dg = dg.take(list(idxKeep))
dg.loc[:, "w"] = 1
if self.verbose:
print("Sample observations from truncated gaussian likelihood...")
zerr = np.ones(len(dg.z))
#zerr = dg.loc[:,"z"].to_numpy()/4
dg.loc[:, "z_err"] = zErrFac * np.clip(zerr, a_min=None, a_max=0.01)
dg.loc[:, "z"] = sample_trunc_gaussian(mu=dg.loc[:, "z"],
sigma=dg.loc[:, "z_err"],
lower=0,
size=1)
####
from astropy.cosmology import FlatLambdaCDM
fiducialcosmo = FlatLambdaCDM(H0=70.0, Om0=0.3)
area = 2 * np.pi
zmax1 = 1.0001 * np.max(
dg[(dg.theta.to_numpy() < np.pi / 2)].z.to_numpy())
zmax2 = 1.0001 * np.max(
dg[(dg.theta.to_numpy() > np.pi / 2)].z.to_numpy())
self.zedges1 = np.linspace(0, zmax1, 90 + 1)
self.zedges2 = np.linspace(0, zmax2, 90 + 1)
z1 = self.zedges1[:-1]
z2 = self.zedges1[1:]
vol1 = area * (fiducialcosmo.comoving_distance(z2).value**3 -
fiducialcosmo.comoving_distance(z1).value**3) / 3
self.zcenters1 = 0.5 * (z1 + z2)
z1 = self.zedges2[:-1]
z2 = self.zedges2[1:]
self.zcenters2 = 0.5 * (z1 + z2)
vol2 = area * (fiducialcosmo.comoving_distance(z2).value**3 -
fiducialcosmo.comoving_distance(z1).value**3) / 3
coarseden1 = np.zeros(vol1.shape)
coarseden2 = np.zeros(vol2.shape)
###
if not self._useDirac:
dg.loc[:, "z_lower"] = dg.loc[:, "z"]
dg.loc[:, "z_lowerbound"] = dg.loc[:, "z"]
dg.loc[:, "z_upper"] = dg.loc[:, "z"]
dg.loc[:, "z_upperbound"] = dg.loc[:, "z"]
L = 0
block = 10000
if self.verbose:
print("Computing galaxy posteriors...")
while True:
R = L + block
# evaluate likelihood at fixed observations on sensible grids in mu
# note that sigma depends on mu as well.
if R >= len(dg):
lowerbound = dg.z.to_numpy(
)[L:] - 7 * dg.z_err.to_numpy()[L:]
lowerbound[lowerbound < 0] = 0
upperbound = dg.z.to_numpy(
)[L:] + 7 * dg.z_err.to_numpy()[L:]
else:
lowerbound = dg.z.to_numpy(
)[L:R] - 7 * dg.z_err.to_numpy()[L:R]
lowerbound[lowerbound < 0] = 0
upperbound = dg.z.to_numpy(
)[L:R] + 7 * dg.z_err.to_numpy()[L:R]
#lowerbound = np.zeros(lowerbound.shape)
#upperbound = np.ones(upperbound.shape)*0.1
mugrid = np.linspace(lowerbound, upperbound, 400).T
# remove leading zeros (if lowerbound = 0), sigma=0 would follow and is ill-defined
mugrid = mugrid[:, 1:]
# copy the algorithm to compute the error from what used to be mu
# (despite being called z), the true redshift
#sigmagrid = mugrid/4
sigmagrid = np.ones(mugrid.shape)
sigmagrid = zErrFac * np.clip(
sigmagrid, a_min=None, a_max=0.01)
# fix observation to dg.z, eval as function of truth mu
if R >= len(dg):
pdfs = trunc_gaussian_pdf(dg.loc[:, "z"].to_numpy()[L:],
mu=mugrid,
sigma=sigmagrid,
lower=0)
else:
pdfs = trunc_gaussian_pdf(dg.loc[:, "z"].to_numpy()[L:R],
mu=mugrid,
sigma=sigmagrid,
lower=0)
# multiply by prior
#pdfs *= mugrid**2
rsqdrdz = fiducialcosmo.comoving_distance(
mugrid).value**2 / fiducialcosmo.H(mugrid).value
pdfs *= rsqdrdz
# pdfs *= mugrid**2
# fit keelin pdfs to this posterior. normalization is not necessary
####
if R >= len(dg):
mask1 = (dg.theta.to_numpy()[L:] < np.pi / 2)
mask2 = (dg.theta.to_numpy()[L:] > np.pi / 2)
else:
mask1 = (dg.theta.to_numpy()[L:R] < np.pi / 2)
mask2 = (dg.theta.to_numpy()[L:R] > np.pi / 2)
# actually prior is not constant in comoving for the part that drops!
pdfs[mask1, :] = pdfs[mask1, :] * compl_of_z(mugrid[mask1, :])
cdfs = np.cumsum(pdfs, axis=1)
pdfs = pdfs / ((cdfs[:, -1])[:, np.newaxis])
cdfs = cdfs / ((cdfs[:, -1])[:, np.newaxis])
fits = fit_bounded_keelin_3(0.16, grids=mugrid, pdfs=pdfs)
for i in range(len(self.zcenters2)):
maskz = (self.zedges1[i] < mugrid) & (mugrid <
self.zedges1[i + 1])
mask = mask1[:, np.newaxis] & maskz
coarseden1[i] += np.sum(pdfs[mask]) / vol1[i]
maskz = (self.zedges2[i] < mugrid) & (mugrid <
self.zedges2[i + 1])
mask = mask2[:, np.newaxis] & maskz
coarseden2[i] += np.sum(pdfs[mask]) / vol2[i]
###
if R >= len(dg):
dg.iloc[L:, dg.columns.get_loc("z_lowerbound")] = fits[:,
0]
dg.iloc[L:, dg.columns.get_loc("z_lower")] = fits[:, 1]
dg.iloc[L:, dg.columns.get_loc("z")] = fits[:, 2]
dg.iloc[L:, dg.columns.get_loc("z_upper")] = fits[:, 3]
dg.iloc[L:, dg.columns.get_loc("z_upperbound")] = fits[:,
4]
break
else:
dg.iloc[L:R, dg.columns.get_loc("z_lowerbound")] = fits[:,
0]
dg.iloc[L:R, dg.columns.get_loc("z_lower")] = fits[:, 1]
dg.iloc[L:R, dg.columns.get_loc("z")] = fits[:, 2]
dg.iloc[L:R, dg.columns.get_loc("z_upper")] = fits[:, 3]
dg.iloc[L:R, dg.columns.get_loc("z_upperbound")] = fits[:,
4]
# dg.z[L:R] = fits[:, 2]
# dg.z_lower[L:R] = fits[:,1]
# dg.z_upper[L:R] = fits[:,3]
# dg.z_lowerbound[L:R] = fits[:,0]
# dg.z_upperbound[L:R] = fits[:,4]
# mask = dg.z_lower < 1e-5
# dg.loc[mask, "z_lower"] = dg.z[mask]*0.5
# dg.loc[mask, "z_lowerbound"] = 0.0
L += block
self.compl1 = coarseden1 / 0.05
self.compl2 = coarseden2 / 0.05
dg.loc[:,
"pix" + str(self._nside)] = hp.ang2pix(self._nside, dg.theta,
dg.phi)
self.data = self.data.append(dg, ignore_index=True)
sigma_8=sigma_val,
z=boxRedshift,
delta_h=DeltaVir_bn98(boxRedshift),
delta_wrt='mean',
Mmin=7,
Mmax=16.5)
f_BH = lambda sigma, A, a, p, q: A * (2. / n.pi)**(
0.5) * (1 + (sigma**2. / (a**delta_c * 2.))**
(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)
#plt.xlabel("Separation "+"({0.unit:s})".format(1.*SepUnit))
#plt.show()
closematch_zD = d2d < (1*u.arcsec)
notmatch_zD = np.invert(closematch_zD)
print('%i zDeep galaxies are also measured by MOSDEF' % sum(1 for i in closematch_zD if i))
cosmos = cosmos[notmatch_zD]
zDeepCoord = zDeepCoord[notmatch_zD]
print('This leaves %i zDeep galaxies in our sample' % len(cosmos))
fig, ax = plt.subplots()
binwidth=0.025
ax.hist(cosmos['z_spec'],bins=np.arange(min(cosmos['z_spec']),
max(cosmos['z_spec']) + binwidth, binwidth))
ax.set_xlabel(r'$z_{spec}$')
ax.set_ylabel('N')
plt.show()'''
comdist0 = cosmo.comoving_distance(2.15)
binfac = 2.
dcomdist_dz = 2997. / cosmo.H(2.35)
xpos = comdist0 * (cosmos['ra'] - ra0) / np.cos(
0.5 * np.abs(cosmos['dec'] + dec0) * np.pi / 180.) * binfac * np.pi / 180.
ypos = comdist0 * (cosmos['dec'] - dec0) * binfac * np.pi / 180.
zpos = (cosmos['z_spec'] - zmin) * dcomdist_dz * binfac
in_vol = np.where((xpos.value > 1) & (xpos.value < 35) & (ypos.value > 1)
& (ypos.value < 47) & (zpos.value > 1) & (zpos.value < 679))
print np.shape(in_vol)
def include_vol_prior(self, df):
batchSize = 10000
nBatches = max(int(len(df) / batchSize), 1)
if self.verbose:
print("Computing galaxy posteriors...")
from keelin import convolve_bounded_keelin_3
from astropy.cosmology import FlatLambdaCDM
fiducialcosmo = FlatLambdaCDM(H0=70.0, Om0=0.3)
zGrid = np.linspace(0, 1.4 * np.max(df.z_upperbound), 500)
jac = fiducialcosmo.comoving_distance(
zGrid).value**2 / fiducialcosmo.H(zGrid).value
from scipy import interpolate
func = interpolate.interp1d(zGrid, jac, kind='cubic')
def convolve_batch(df, func, batchId, nBatches):
N = len(df)
# actual batch size, different from batchSize only due to integer rounding
n = int(N / nBatches)
start = n * batchId
stop = n * (batchId + 1)
if batchId == nBatches - 1:
stop = N
batch = df.iloc[start:stop]
if self.verbose:
if batchId % 100 == 0:
print("Batch " + str(batchId) + " of " + str(nBatches))
ll = batch.z_lowerbound.to_numpy()
l = batch.z_lower.to_numpy()
m = batch.z.to_numpy()
u = batch.z_upper.to_numpy()
uu = batch.z_upperbound.to_numpy()
return convolve_bounded_keelin_3(func,
0.16,
l,
m,
u,
ll,
uu,
N=1000)
res = np.vstack(
parmap(lambda b: convolve_batch(df, func, b, nBatches),
range(nBatches)))
mask = (res[:, 0] >= res[:, 1]) | (res[:, 1] >= res[:, 2]) | (
res[:, 2] >= res[:, 3]) | (res[:, 3] >= res[:, 4]) | (res[:, 0] <
0)
if self.verbose:
print(
'Removing ' + str(np.sum(mask)) +
' galaxies with unfeasible redshift pdf after r-squared prior correction.'
)
df.z_lowerbound = res[:, 0]
df.z_lower = res[:, 1]
df.z = res[:, 2]
df.z_upper = res[:, 3]
df.z_upperbound = res[:, 4]
df = df[~mask]
return df
2.78, 1.87, 1.45, 1.19, 1.01, 0.87, 0.77, 0.76, 0.88, 0.91, 0.91, 0.91,
1.00, 1.17, 1.50, 2.36, 3.62, 4.79
])
sigma_H_s_rel_ary = .01 * np.array([
5.34, 3.51, 2.69, 2.20, 1.85, 1.60, 1.41, 1.35, 1.42, 1.41, 1.38, 1.36,
1.46, 1.66, 2.04, 3.15, 4.87, 6.55
])
cosmo = FlatLambdaCDM(H0=69, Om0=0.3, m_nu=20 * u.meV)
s = 150 * u.Mpc # BAO scale
# Fiducial values for dA/s and Hs
dA_div_s_ary = np.array([(cosmo.angular_diameter_distance(z) / s).value
for z in z_ary])
H_s_ary = np.array([(cosmo.H(z) * s / const.c * 1000).value for z in z_ary])
# Absolute errors on dA/s and Hs
sigma_dA_div_s_ary = sigma_dA_div_s_rel_ary * dA_div_s_ary
sigma_H_s_ary = sigma_H_s_rel_ary * H_s_ary
# Defines dA and H arrays
da = dA_div_s_ary * s.value
hh = H_s_ary / s.value
zz = z_ary
# Defines absolute error arrays
err_da = sigma_dA_div_s_ary * s.value
err_hh = sigma_H_s_ary / s.value
err_zz = np.zeros(len(z_ary))
ax1.set_yticks(rc[::5])
ax1.set_yticklabels(n.round(rc[::5], 2))
ax1.grid()
ax2 = ax1.twinx()
ax2.plot(zs, rc, 'k')
ax2.set_ylabel('log10(M collapsing)')
ax2.set_yticks(rc[::5])
ax2.set_yticklabels(n.round(n.log10(mc[::5]), 2))
p.savefig(join(dir, "spherical-collapse-r.png"))
p.clf()
n.savetxt(join("..", "data", "sc-relation.txt"),
n.transpose([zs, dc, mc, rc]),
header="z delta_c mvir_star rvir_star")
hrr = (cosmo.H(data['redshift']).value / 100. / cosmo.h)**3.
#h2.mean_density0
# x coordinates definition
logsig = n.log10(data['sigmaM']) #
lognu = n.log10(data['nuM'])
log_mvir = (data["log_" + qty + "_min"] + data["log_" + qty + "_max"]) / 2.
mvir = 10**log_mvir
# y coordinates
log_MF = n.log10(mvir * data["dNdVdlnM_" + cos] / data["rhom"])
log_MF_c = n.log10(data["dNdVdlnM_" + cos + "_c"])
ff = mvir * data["dNdVdlnM_" + cos] / data["rhom"] / abs(
data["dlnsigmaM1_o_dlnM"]) * hrr
ff_nu = data['nuM'] * ff
