def get_masses(nu, z, box=0):
Ombh2, Omch2, w, ns, ln10As, H0, Neff, sig8 = np.genfromtxt(
AD.path_to_building_box_cosmologies())[int(box)]
h = H0 / 100.
Ob = Ombh2 / h**2
Oc = Omch2 / h**2
Om = Ob + Oc
cosmo = {
"om": Om,
"ob": Ob,
"ol": 1 - Om,
"h": h,
"s8": sig8,
"ns": ns,
"w0": w,
"Neff": Neff,
"wa": 0
}
cc.set_cosmology(cosmo)
Ms = np.logspace(8, 17, num=100) #Msun/h
a = 1.0 / (1 + z)
nus = np.array([DELTAC / cc.sigmaMtophat(Mi, a) for Mi in Ms])
from scipy.interpolate import interp1d
spl = interp1d(nus, np.log(Ms))
return np.exp(spl(nu)) #np.log10(spl(nu))
def bias_denominator_integrand(logm, a, delta, cd) : import cosmocalc import numpy as np ## Set the cosmocalc cosmology cosmocalc.set_cosmology(cd) ## Need the mass in the integral, not the log10(mass) m = np.power(10., logm) ## Return the integrand return cosmocalc.tinker2010_mass_function(m, a, delta)*m
def get_cosmocalc_beta(M, z):
a = 1. / (1 + z)
import cosmocalc as cc
MF = cc.tinker2008_mass_function
cc.set_cosmology(cos)
d = 1.00001
dndM1 = MF(M, a, 200)
dndM2 = MF(M * d, a, 200)
return np.log(dndM2 / dndM1) / np.log(d)
def set_new_cosmology(self, cosmo_dict, scale_factor):
# Constants
G = 4.52e-48 # Newton's gravitional constant in Mpc^3/s^2/Solar Mass
Mpcperkm = 3.241e-20 # Mpc/km; used to convert H0 to s^-1
self.cosmo_dict = cosmo_dict
cc.set_cosmology(cosmo_dict)
self.build_splines(scale_factor)
Om, H0 = cosmo_dict["om"], cosmo_dict["h"] * 100.0
self.rhom = Om * 3.0 * (H0 * Mpcperkm) ** 2 / (8 * np.pi * G * (H0 / 100.0) ** 2) # Msun h^2/Mpc^3
def set_new_cosmology(self, cosmo_dict):
"""Specify a new set of cosmological parameters and then build splines that depend on these.
Args:
cosmo_dict (dictionary): Keys are cosmological parameters, specifically om for Omega_matter and h for Hubble constant/100.
"""
cc.set_cosmology(cosmo_dict)
Om = cosmo_dict["om"]
self.rhom = Om * rhocrit #Msunh^2/Mpc^3
self.cosmo_dict = cosmo_dict
return
def set_new_cosmology(self, cosmo_dict):
"""Specify a new set of cosmological parameters and then build splines that depend on these.
Args:
cosmo_dict (dictionary): Keys are cosmological parameters, specifically om for Omega_matter and h for Hubble constant/100.
"""
print "setting cc cos:",cosmo_dict
cc.set_cosmology(cosmo_dict)
print "sigma inside = ",cc.sigmaMtophat(1e14, 0.25)
Om = cosmo_dict["om"]
self.rhom=Om*rhocrit#Msunh^2/Mpc^3
self.cosmo_dict = cosmo_dict
return
def set_cosmology(cos):
ombh2, omch2, w0, ns, ln10As, H0, Neff, sigma8 = cos
h = H0 / 100.
Ob = ombh2 / h**2
Om = Ob + omch2 / h**2
cosmo_dict = {
"om": Om,
"ob": Ob,
"ol": 1 - Om,
"ok": 0.0,
"h": h,
"s8": sigma8,
"ns": ns,
"w0": w0,
"wa": 0.0
}
cc.set_cosmology(cosmo_dict)
return
def calcMassFunction(self, z=0, delta=200):
# mass bins, definitions, z bins
if hasattr(delta, '__iter__'):
self.ndefs = len(delta)
else:
self.ndefs = 1
delta = [delta]
if hasattr(z , '__iter__'):
self.nzbins = len(z)
else:
z=[z]
self.nzbins = 1
self.nbands = self.ndefs
cd = {
"OmegaM":0.286,
"OmegaB":0.05,
"OmegaDE":0.714,
"OmegaK":0.0,
"h":0.7,
"Sigma8":0.82,
"SpectralIndex":0.96,
"w0":-1.0,
"wa":0.0
}
cosmocalc.set_cosmology(cd)
mass_fn_n = np.zeros((len(self.massbins)-1, self.ndefs, self.nzbins))
mass_fn_error = np.zeros((len(self.massbins)-1, self.ndefs, self.nzbins))
for k in range(self.nzbins):
for j in range(self.ndefs):
for i in range(len(self.massbins)-1):
integral = quad(lambda mass: cosmocalc.tinker2008_mass_function(mass, 1/(1+z[k]), delta[j]), self.massbins[i], self.massbins[i+1])
mass_fn_n[i][j][k] = integral[0]
mass_fn_error[i][j][k] = integral[1]
self.y = mass_fn_n
self.ye = mass_fn_error
def plot_tinker_bias(cosmo_dict, i):
cc.set_cosmology(cosmo_dict)
for j in range(N_z):
a = scale_factors[j]
#First plot the data.
data = np.loadtxt(datapath%(i, i, j))
lM_bins = data[:,:2]
lM = np.mean(data[:, :2], 1)
M = 10**lM
N = data[:,2]
cov = np.loadtxt(covpath%(i, i, j))
err = np.sqrt(np.diagonal(cov))
bG = get_bG(cosmo_dict, a, M)
plt.plot(M, bG, c=cmap(c[j]))
plt.xlabel(xlabel)
plt.ylabel(ylabel)
plt.xscale('log')
plt.subplots_adjust(bottom=0.15)
plt.show()
def set_cosmology(self, cosmo_dict):
self.cosmo_dict = cosmo_dict
self.rhom = cosmo_dict['om'] * rhocrit #Msun h^2/Mpc^3
cc.set_cosmology(cosmo_dict)
cos = self.cos_from_dict(cosmo_dict)
self.t08_slopes_intercepts = self.t_08.predict_slopes_intercepts(cos)
redshift=redshifts[z_index],
lM_bins=lM_bins)
N_emu = n * volume
#Make the analytic covariance matrix
cov_an = np.diag(N_emu)
#Set up cosmocalc
ombh2, omch2, w0, ns, ln10As, H0, Neff, sigma8 = test_cosmo
h = H0 / 100.
Ob = ombh2 / h**2
Om = Ob + omch2 / h**2
cosmo_dict = {"om":Om,"ob":Ob,"ol":1-Om,\
"ok":0.0,"h":h,"s8":sigma8,\
"ns":ns,"w0":w0,"wa":0.0}
cc.set_cosmology(cosmo_dict) #Used to create the splines in cosmocalc
#Get the biases
bias = np.zeros_like(lM)
a = 1. / (1 + redshifts[z_index])
for i in xrange(0, len(lM)):
M = 10**lM[i]
bias[i] = cc.tinker2010_bias(M, a, 200)
#Get sigmaR
R = (3. / 4. / np.pi * volume)**(1. / 3.)
sigmaR = cc.sigmaRtophat_exact(R, a)
print sigmaR**2
for i in xrange(0, len(bias)):
for j in xrange(0, len(bias)):
def get_cc_prediction(bin_center_mass, a, cosmo):
import cosmocalc as cc
cc.set_cosmology(cosmo)
return np.array(
[cc.tinker2008_mass_function(M, a, 200) * M for M in bin_center_mass])
test_cosmo = all_cosmologies[box]
test_data = data[box]
training_cosmologies = np.delete(all_cosmologies,box,0)
training_data = np.delete(data,box,0)
#Train
mf_emulator = mfe.mf_emulator("test")
mf_emulator.train(training_cosmologies,training_data)
#Set up cosmocalc
ombh2,omch2,w0,ns,ln10As,H0,Neff,sigma8 = test_cosmo
h = H0/100.
Ob = ombh2/h**2
Om = Ob + omch2/h**2
cosmo_dict = {"om":Om,"ob":Ob,"ol":1-Om,"ok":0.0,"h":h,"s8":sigma8,"ns":ns,"w0":w0,"wa":0.0}
cc.set_cosmology(cosmo_dict)
#Now loop over each redshift bin
for zind in xrange(0,N_z):
z = redshifts[zind]
a = scale_factors[zind]
sigmaR = cc.sigmaRtophat_exact(R,a)
#Read in the data
MF_data = np.genfromtxt("../../all_MF_data/building_MF_data/full_mf_data/Box%03d_full/Box%03d_full_Z%d.txt"%(box,box,zind))
lM_bins = MF_data[:,:2]
lM = np.mean(lM_bins,1)
N_data = MF_data[:,2]
N_data_array.append(N_data)
logN_data_array.append(np.log(N_data))
