def C_l_mu_single_ell(ell):
Kp = np.geomspace(1e-4, 100, n_points)
Mu = np.linspace(-0.9999, 0.9999, n_points)
Z = np.geomspace(1e-4, z_r, n_points)
mu, kp, z = np.meshgrid(Mu, Kp, Z)
H_z = uf.H(Z)
chi_z = uf.chi(Z)
#chi_Z=chi(Z)
tau_z = uf.tau_inst(Z)
f_z = uf.f(Z)
D_z = uf.D_1(Z)
const = 1e12 * T_rad**2 * x**2 / cc.c_light_Mpc_s * (
sigma_T * rho_g0 / (mu_e * m_p))**2 / 8 / np.pi**2
#kp_norm=np.linalg.norm(Kp)
#k_norm=np.linalg.norm(ell/chi_Z)
k = ell / chi_z
K = np.sqrt(k**2 + kp**2 - 2 * k * kp * mu)
integral = sp.integrate.trapz(sp.integrate.trapz(
sp.integrate.trapz(Mps_interpf(kp) * np.exp(-2 * tau_z) * f_z**2 *
D_z**4 * H_z * (1 - mu**2) * (1 + z)**2 / chi_z**2,
Mu,
axis=0),
Kp,
axis=0),
Z,
axis=0)
return integral
def C_l_mu_Delta_b(k, z):
Kp = np.geomspace(k_min, k_max, n_points)
Mu = np.linspace(-0.9999, 0.9999, n_points)
mu, kp = np.meshgrid(Mu, Kp)
#chi_Z=chi(Z)
H_z = uf.H(z)
f_z = uf.f(z)
D_z = uf.D_1(z)
#kp_norm=np.linalg.norm(Kp)
#k_norm=np.linalg.norm(ell/chi_Z)
C_l = np.array([])
for i in k:
K = np.sqrt(np.abs(i**2 + kp**2 - 2 * i * kp * mu))
#mu=np.dot(k,Kp)/(k_norm*kp_norm)
#I=k*(k-2*kp*j)*(1-j**2)/(k**2+kp**2-2*k*kp*j)
constants = 1 / ((2 * np.pi**2) * (2 * np.pi)**(3)) * 2 * np.pi
integral = [
constants * sp.integrate.trapz(sp.integrate.trapz(
i**3 * f_z**2 * Mps_interpf(kp) * Mps_interpf(K) * i *
(i - 2 * kp * mu) * (1 - mu**2) / (K**2) / (1 + z)**2 * D_z**4,
Kp,
axis=0),
Mu,
axis=0)
]
C_l = np.append(C_l, integral)
return C_l
def powerspec_final(ell):
z1, z2 = np.meshgrid(z, z)
chi_z1 = chi(z1)
chi_z2 = chi(z2)
f_z1 = uf.f(z1)
f_z2 = uf.f(z2)
D_z1 = uf.D_1(z1)
D_z2 = uf.D_1(z2)
tau_z1 = tau(z1)
tau_z2 = tau(z2)
H_z = uf.H(z)
chi_z = chi(z)
tau_z = uf.tau_inst(z)
f_z = uf.f(z)
D_z = uf.D_1(z)
Mps = np.array([])
for i in ell:
Integrand = [
sp.integrate.trapz(powerspec(np.sqrt(j**2 + i**2 / chi_z**2)), z)
for j in kpar
]
Integral = sp.integrate.trapz(Integrand, kpar)
#Integral=sp.integrate.trapz((1+z)**2/chi_z**2*powerspec(i/chi_z)*D_z**4*H_z*f_z**2*np.exp(-2*tau_z),z)
#Integral=[sp.integrate.trapz(sp.integrate.trapz((1+z1)*(1+z2)*np.exp(-tau_z1)
#*np.exp(-tau_z2)*2*f_z1*f_z2*D_z1**2*D_z2**2/chi_z1**2*powerspec(i/chi_z1),z,axis=0),z,axis=0)]
Mps = np.append(Mps, Integral)
return Mps
def C_l_integrand(ell, z):
Kp = np.geomspace(1e-4, k_max, n_points)
Mu = np.linspace(-0.9999, 0.9999, n_points)
mu, kp = np.meshgrid(Mu, Kp)
H_z = uf.H(z)
chi_z = uf.chi(z)
#chi_Z=chi(Z)
tau_z = uf.tau_inst(z)
f_z = uf.f(z)
D_z = uf.D_1(z)
const = 1e12 * T_rad**2 * x**2 / cc.c_light_Mpc_s * (
sigma_T * rho_g0 / (mu_e * m_p))**2 / 8 / np.pi**2
#kp_norm=np.linalg.norm(Kp)
#k_norm=np.linalg.norm(ell/chi_Z)
C_l = np.array([])
for i in ell:
k = i / chi_z
K = np.sqrt(np.abs(k**2 + kp**2 - 2 * k * kp * mu))
integral = [
const * sp.integrate.trapz(sp.integrate.trapz(
k * (k - 2 * kp * mu) *
(1 - mu**2) / K**2 * Mps_interpf(kp) * Mps_interpf(K) *
(1 + z)**2 * np.exp(-2 * tau_z) * f_z**2 * D_z**4 / chi_z**2 *
H_z,
Mu,
axis=0),
Kp,
axis=0)
]
C_l = np.append(C_l, integral)
return C_l
def tau(z):
tau=np.array([])
for i in z:
z_temp=np.linspace(0,i,n_points)
tau_der=sigma_T*cc.c_light_Mpc_s*ionized_electron_number(z_temp)/((1+z_temp)*uf.H(z_temp))
tau=np.append(tau,sp.integrate.trapz(tau_der,z_temp))
return tau
def tau(z):
tau_der = sigma_T * cc.c_light_Mpc_s * ionized_electron_number(z) / (
(1 + z) * uf.H(z))
tau = sp.integrate.trapz(tau_der, z)
return tau
def crosscorr_rec_coords(
ell, z_i, y, delta_z
): #with the assumption that zi=z so no cos factor, and we have dz=redshift bin width=2*delta_z defined above
n = n_points #number of points over which to integrate
Kp_par = np.geomspace(1.e-6, .15, n)
Kp_perp = np.geomspace(1.e-6, 1., n)
Z_min = z_i - delta_z
Z_max = z_i + delta_z
Z = np.geomspace(Z_min, Z_max, n)
kp_perp, kp_par, z = np.meshgrid(Kp_perp, Kp_par, Z)
chi_z = chi(z)
T_mean_zi = uf.T_mean(z_i)
chi_zi = chi(z_i)
chi_z = chi(z)
f_zi = uf.f(z_i)
f_z = uf.f(z)
D_zi = uf.D_1(z_i)
r_zi = uf.r(z_i)
D_z = uf.D_1(z)
H_zi = uf.H(z_i)
tau_z = uf.tau_inst(z)
kpar = y / uf.r(z)
const = 1.e6 / (
4. * np.pi**2
) * T_rad * T_mean_zi**2 / cc.c_light_Mpc_s * f_zi * D_zi**2 * H_zi / (
chi_zi**2 * r_zi) / (1. + z_i) * x * (sigma_T * rho_g0 / (mu_e * m_p))
kperp = ell / chi_z
k = np.sqrt(kperp**2 + kpar**2)
kp = np.sqrt(kp_perp**2 + kp_par**2)
cos_theta = kp_par / kp #cos_theta=u, theta is azimuthal angle between k' and z (line of sight) axis
sin_theta = kp_perp / kp
sin_gamma = kpar / k #gamma is measured between k and xy plane, i.e. elevation of k
cos_gamma = kperp / k
zeta = sin_gamma * cos_theta + cos_gamma * sin_theta
k_dot_kp = kperp * kp_perp + kpar * kp_par * zeta
K = np.sqrt(k**2 + kp**2 - 2 * k_dot_kp)
theta_K = kpar / K / k**2 * (
k**2 - k_dot_kp) - kp * kperp * np.sqrt(1 - zeta**2) / k / K
theta_kp = cos_theta
rsd = 1. + f_zi * kpar**2 / k**2
I = theta_kp * (theta_kp / kp**2 + theta_K / K / kp)
integrand_1 = f_z * D_z**2 * (
1 + z) * np.exp(-tau_z) * rsd**2 * Mps_interpf(kp) * Mps_interpf(
K) * theta_kp**2 / kp**2
integrand_2 = f_z * D_z**2 * (
1 + z) * np.exp(-tau_z) * rsd**2 * Mps_interpf(kp) * Mps_interpf(
K) * theta_kp * theta_K / kp / K
integral_1 = const * sp.integrate.trapz(sp.integrate.trapz(
sp.integrate.trapz(integrand_1, Kp_perp, axis=0), Kp_par, axis=0),
Z,
axis=0)
integral_2 = const * sp.integrate.trapz(sp.integrate.trapz(
sp.integrate.trapz(integrand_2, Kp_perp, axis=0), Kp_par, axis=0),
Z,
axis=0)
return integral_1 + integral_2
def crosscorr_integral_y_rec_coords(
ell, z_i, delta_z
): #This is not working out-don't try this for now. Just leave it.
n = n_points #number of points over which to integrate
Kp_par = np.geomspace(1.e-6, .15, n)
Kp_perp = np.geomspace(1.e-6, 1., n)
Z_min = z_i - delta_z
Z_max = z_i + delta_z
z = np.geomspace(Z_min, Z_max, n)
Kpar = np.geomspace(1.e-6, .15, n)
kp_perp, kp_par, kpar = np.meshgrid(Kp_perp, Kp_par, Kpar)
chi_z = chi(z)
T_mean_zi = uf.T_mean(z_i)
chi_zi = chi(z_i)
f_zi = uf.f(z_i)
f_z = uf.f(z)
D_zi = uf.D_1(z_i)
r_zi = uf.r(z_i)
D_z = uf.D_1(z)
H_zi = uf.H(z_i)
tau_z = uf.tau_inst(z)
kpar = y / uf.r(z)
const = 1.e6 / (
8. * np.pi**3
) * T_rad * T_mean_zi**2 / cc.c_light_Mpc_s * f_zi * D_zi**2 * H_zi / (
chi_zi**2) / (1. + z_i) * x * (sigma_T * rho_g0 / (mu_e * m_p))
kperp = ell / chi_zi
k = np.sqrt(kperp**2 + kpar**2)
kp = np.sqrt(kp_perp**2 + kp_par**2)
cos_theta = kp_par / kp #cos_theta=u, theta is azimuthal angle between k' and z (line of sight) axis
sin_theta = kp_perp / kp
sin_gamma = kpar / k #gamma is measured between k and xy plane, i.e. elevation of k
cos_gamma = kperp / k
zeta = sin_gamma * cos_theta + cos_gamma * sin_theta
k_dot_kp = kperp * kp_perp + kpar * kp_par * zeta
K = np.sqrt(k**2 + kp**2 - 2 * k_dot_kp)
theta_K = kpar / K / k**2 * (
k**2 - k_dot_kp) - kp * kperp * np.sqrt(1 - zeta**2) / k / K
theta_kp = cos_theta
rsd = 1. + f_zi * kpar**2 / k**2
I = theta_kp * (theta_kp / kp**2 + theta_K / K / kp)
z_dep_integ = sp.integrate.trapz(f_z * D_z**2 * (1 + z) * np.exp(-tau_z),
z)
integrand_1 = rsd**2 * Mps_interpf(kp) * Mps_interpf(
K) * theta_kp**2 / kp**2 * kp_perp
integrand_2 = rsd**2 * Mps_interpf(kp) * Mps_interpf(
K) * theta_kp * theta_K / kp / K * kp_perp
integral_1 = const * z_dep_integ * sp.integrate.trapz(sp.integrate.trapz(
sp.integrate.trapz(integrand_1, Kp_perp, axis=0), Kp_par, axis=0),
Kpar,
axis=0)
integral_2 = const * z_dep_integ * sp.integrate.trapz(sp.integrate.trapz(
sp.integrate.trapz(integrand_2, Kp_perp, axis=0), Kp_par, axis=0),
Kpar,
axis=0)
return integral_1 + integral_2
def crosscorr_squeezedlim(
ell, z_i, y, delta_z
): #with the assumption that zi=z so no cos factor, and we have dz=redshift bin width=2*delta_z defined above
n = n_points #number of points over which to integrate
#y=np.geomspace(1.,3000.,n)
U = np.linspace(-.9999, .9999, n)
Kp = np.geomspace(1.e-6, .1, n)
Z_min = z_i - delta_z
Z_max = z_i + delta_z
z = np.geomspace(Z_min, Z_max, n)
u, kp = np.meshgrid(U, Kp)
T_mean_zi = uf.T_mean(z_i)
chi_zi = chi(z_i)
chi_z = chi(z)
f_zi = uf.f(z_i)
f_z = uf.f(z)
D_zi = uf.D_1(z_i)
r_zi = uf.r(z_i)
D_z = uf.D_1(z)
H_zi = uf.H(z_i)
tau_z = uf.tau_inst(z)
kpar = y / uf.r(z)
const = 1.e6 / (
4. * np.pi**2
) * T_rad * T_mean_zi**2 / cc.c_light_Mpc_s * f_zi * D_zi**2 * H_zi / (
chi_zi**2 * r_zi) / (1. + z_i) * x * (sigma_T * rho_g0 / (mu_e * m_p))
#Cl=np.array([])
kp_perp = kp * np.sqrt(1 - u**2)
kp_par = kp * u
k_perp = ell / chi_zi
k = np.sqrt(k_perp**2 + kpar**2)
rsd = 1. + f_zi * kpar**2 / k**2
zeta = (kpar / k * u + k_perp / k * np.sqrt(1 - u**2))
k_dot_kp = k_perp * kp_perp + kpar * kp_par * zeta
K = np.sqrt(k**2 + kp**2 - 2 * k_dot_kp)
#theta_kp=kpar*zeta/k+k_perp*np.sqrt(np.abs(1-zeta**2))/k
theta_K = kpar / K / k**2 * (
k**2 - k_dot_kp) - kp * k_perp * np.sqrt(1 - zeta**2) / k / K
#print (theta_K.min(),theta_K.max())
theta_kp = u
#theta_K=np.where(theta_K > 0, theta_K, 0)
I = theta_kp * (theta_kp / kp**2 + theta_K / K / kp)
z_integral = sp.integrate.trapz(f_z * D_z**2 * (1 + z) * np.exp(-tau_z), z)
integrand_1 = z_integral * Mps_interpf(kp) * Mps_interpf(
K) * rsd**2 * theta_kp**2
#+theta_K/K/kp)#-mu*kp*np.gradient(Mps_interpf(k),axis=0))
integrand_2 = z_integral * Mps_interpf(kp) * Mps_interpf(
k) * rsd**2 * kp**2 * theta_kp * theta_K / kp / K
integral_sing_1 = const * sp.integrate.trapz(
sp.integrate.trapz(integrand_1, U, axis=0), Kp, axis=0)
integral_sing_2 = const * sp.integrate.trapz(
sp.integrate.trapz(integrand_2, U, axis=0), Kp, axis=0)
#Cl=np.append(Cl,integral)
return integral_sing_1 + integral_sing_2
def crosscorr_squeezed_integral_y(ell, z_i, delta_z):
n = n_points #number of points over which to integrate
#y=np.geomspace(1.,3000.,n)
#Kpar=y/uf.r(z)
Kpar = np.geomspace(1.e-6, .15, n)
U = np.linspace(-.9999, .9999, n)
Kp = np.geomspace(1.e-6, .1, n)
Z_min = z_i - delta_z
Z_max = z_i + delta_z
z = np.geomspace(Z_min, Z_max, n)
u, kp, kpar = np.meshgrid(U, Kp, Kpar)
T_mean_zi = uf.T_mean(z_i)
chi_zi = chi(z_i)
chi_z = chi(z)
f_zi = uf.f(z_i)
f_z = uf.f(z)
D_zi = uf.D_1(z_i)
r_zi = uf.r(z_i)
D_z = uf.D_1(z)
H_zi = uf.H(z_i)
tau_z = uf.tau_inst(z)
const = 1.e6 / (
8. * np.pi**3
) * T_rad * T_mean_zi**2 / cc.c_light_Mpc_s * f_zi * D_zi**2 * H_zi / (
chi_zi**2) / (1. + z_i) * x * (sigma_T * rho_g0 / (mu_e * m_p))
#Cl=np.array([])
kp_perp = kp * np.sqrt(1 - u**2)
kp_par = kp * u
k_perp = ell / chi_zi
k = np.sqrt(k_perp**2 + kpar**2)
rsd = 1. + f_zi * kpar**2 / k**2
zeta = (kpar / k * u + k_perp / k * np.sqrt(1 - u**2))
k_dot_kp = k_perp * kp_perp + kpar * kp_par * zeta
K = np.sqrt(k**2 + kp**2 - 2 * k_dot_kp)
#theta_kp=kpar*zeta/k+k_perp*np.sqrt(np.abs(1-zeta**2))/k
theta_K = kpar / K / k**2 * (
k**2 - k_dot_kp) - kp * k_perp * np.sqrt(1 - zeta**2) / k / K
theta_kp = u
#theta_K=np.where(theta_K > 0, theta_K, 0)
I = theta_kp * (theta_kp / kp**2 + theta_K / K / kp)
z_dep_integ = sp.integrate.trapz(f_z * D_z**2 * (1 + z) * np.exp(-tau_z),
z)
integrand = Mps_interpf(kp) * Mps_interpf(
k
) * rsd**2 * kp**2 * I #+theta_K/K/kp)#-mu*kp*np.gradient(Mps_interpf(k),axis=0))
integral_sing = const * z_dep_integ * sp.integrate.trapz(
sp.integrate.trapz(
sp.integrate.trapz(integrand, U, axis=0), Kp, axis=0),
Kpar,
axis=0)
#Cl=np.append(Cl,integral)
return integral_sing
def C_l_quad_integrand(Mu, Kp, Z, ell):
mu, kp, z = np.meshgrid(Mu, Kp, Z)
H_z = uf.H(z)
chi_z = chi(z)
#chi_Z=chi(Z)
tau_z = uf.tau_inst(z)
f_z = uf.f(z)
D_z = uf.D_1(z)
k = ell / chi_z
K = np.sqrt(k**2 + kp**2 - 2 * k * kp * mu)
integrand = k * (k - 2 * kp * mu) * (
1 - mu**2) / K**2 * Mps_interpf(kp) * Mps_interpf(K) * (
1 + z)**2 * H_z * D_z**4 * f_z**2 * np.exp(-2 * tau_z) / chi_z**2
return integrand
def C_l_integrand(ell, z):
H_z = uf.H(z)
chi_z = chi(z)
tau_z = uf.tau_inst(z)
f_z = uf.f(z)
D_z = uf.D_1(z)
const = 1e12 * 8 * np.pi**2 * T_rad**2 * x**2 * (
sigma_T * rho_g0 / (mu_e * m_p))**2 / cc.c_light_Mpc_s
integrand = const * (1 + z)**2 * np.exp(
-2 * tau_z) * chi_z * f_z**2 * H_z * D_z**4 * Delta_b_noredshift(
ell / chi_z) / (2 * ell + 1)**3
##print (np.shape(integrand))
#integrand=np.resize(integrand,(n_points+1))
##print (np.shape(integrand))
return integrand
def C_l(ell, z_min):
z = np.linspace(z_min, 10, n_points)
C_l = np.array([])
for i in ell:
const = 1e12 * 8 * np.pi**2 * T_rad**2 * x**2 / cc.c_light_Mpc_s * (
sigma_T * rho_g0 / (mu_e * m_p))**2 / (2 * i + 1)**3
integrand = const * (1 + z)**4 * uf.H(z) * chi(z) * np.exp(
-2 * tau(z)) * Delta_b(i / chi(z), z)
#print (np.shape(integrand))
#integrand=np.resize(integrand,(n_points+1))
#print (np.shape(integrand))
Redshift_dep = sp.integrate.trapz(integrand, z)
C_l = np.append(C_l, Redshift_dep)
return C_l
def C_l_mu_integral_threeints(ell, z_min):
Kp = np.geomspace(1.e-10, 10., n_points)
Mu = np.linspace(-0.9999, 0.9999, n_points)
Phi = np.geomspace(1.e-4, 2 * np.pi, n_points)
Z = np.geomspace(z_min, z_r, n_points)
mu, phi, kp, z = np.meshgrid(Mu, Phi, Kp, Z)
H_z = uf.H(z)
chi_z = uf.chi(z)
#chi_Z=chi(Z)
tau_z = uf.tau_inst(z)
f_z = uf.f(z)
D_z = uf.D_1(z)
const = 1e12 * T_rad**2 * x**2 / cc.c_light_Mpc_s * (
sigma_T * rho_g0 / (mu_e * m_p))**2 / 16 / np.pi**3
#kp_norm=np.linalg.norm(Kp)
#k_norm=np.linalg.norm(ell/chi_Z)
theta_kp_arr = np.array([])
theta_K_arr = np.array([])
I_arr = np.array([])
C_l = np.array([])
for i in ell:
k = i / chi_z
K = np.sqrt(k**2 + kp**2 - 2 * k * kp * mu * np.cos(phi))
theta_kp = np.sqrt(1 - mu**2)
theta_K = -np.sqrt(1 - mu**2) * kp / K
theta_kp_arr = np.append(theta_kp_arr, theta_kp)
theta_K_arr = np.append(theta_K_arr, theta_K)
I = theta_kp**2 / kp**2 + theta_K * theta_kp / K / kp
I_arr = np.append(I_arr, I)
#I=k*(k-2*kp*mu)*(1-mu**2)/K**2
integral = [
const * sp.integrate.trapz(sp.integrate.trapz(sp.integrate.trapz(
sp.integrate.trapz(
kp**2 * I * Mps_interpf(kp) * Mps_interpf(K) * (1 + z)**2 *
np.exp(-2 * tau_z) * f_z**2 * D_z**4 / chi_z**2 * H_z,
Mu,
axis=0),
Phi,
axis=0),
Kp,
axis=0),
Z,
axis=0)
]
C_l = np.append(C_l, integral)
return C_l, theta_kp_arr, theta_K_arr, I_arr
def C_l_allredshift(ell, z_min):
z = np.geomspace(z_min, z_r, n_points)
f_z = uf.f(z)
D_z = uf.D_1(z)
H_z = uf.H(z)
chi_z = chi(z)
tau_z = tau(z)
C_l = np.array([])
for i in ell:
const = 1e12 * 8 * np.pi**2 * T_rad**2 * x**2 * (
sigma_T * rho_g0 / (mu_e * m_p))**2 / cc.c_light_Mpc_s
integrand = const * (1 + z)**2 * chi_z * np.exp(
-2 * tau_z) * f_z**2 * H_z * Delta_b_noredshift(
i / chi_z) * D_z**4 / (2 * i + 1)**3
Redshift_dep = sp.integrate.trapz(integrand, z)
C_l = np.append(C_l, Redshift_dep)
#print (C_l)
return C_l
def C_l(ell):
C_l=np.array([])
zz=z[:,np.newaxis]
kk=kp[np.newaxis,:]
kk_norm=np.linalg.norm(kk)
for i in ell:
#mu=kk/i
#mu=(i**2+kk**2-(np.abs(i-kk))**2)/(2*i*kk)
#print (mu)
#I=i**2/(kk**2*(i**2+kk**2))
k_norm=np.linalg.norm(i/chi(zz))
mu=np.dot(i/chi(zz),kk)/(k_norm*kk_norm)
#print (mu)
I=i/chi(zz)*(i/chi(zz)-2*kk*mu)*(1-mu**2)/((i/chi(zz))**2+kk**2-2*i/chi(zz)*kk*mu)
constants=(i/chi(zz))**3/((2*np.pi**2)*(2*np.pi)**3)
delta_sq=constants*Mps_interpf(kk)*Mps_interpf(np.abs(i/chi(zz)-kk))*I
const=8*np.pi**2*T_rad**2*x**2/cc.c_light_Mpc_s*(sigma_T*rho_g0/(mu_e*m_p))**2
integrand=[const*(1+zz)**2*uf.f(zz)**2*delta_sq*uf.chi(zz)*uf.H(zz)*np.exp(-2*tau(zz))]
C_l=np.append(C_l,sp.integrate.trapz(sp.integrate.trapz(integrand,zz,axis=0),kp,axis=0))
return C_l
def C_l_mu_integral_squeezed(ell, z_min):
Kp = np.geomspace(1.e-10, .1, n_points)
Mu = np.linspace(-0.9999, 0.9999, n_points)
Z = np.geomspace(z_min, z_r, n_points)
mu, kp, z = np.meshgrid(Mu, Kp, Z)
H_z = uf.H(z)
chi_z = uf.chi(z)
#chi_Z=chi(Z)
tau_z = uf.tau_inst(z)
f_z = uf.f(z)
D_z = uf.D_1(z)
const = 1e12 * T_rad**2 * x**2 / cc.c_light_Mpc_s * (
sigma_T * rho_g0 / (mu_e * m_p))**2 / 8 / np.pi**2
#kp_norm=np.linalg.norm(Kp)
#k_norm=np.linalg.norm(ell/chi_Z)
C_l = np.array([])
for i in ell:
k = i / chi_z
#K=np.sqrt(k**2+kp**2-2*k*kp*mu) #original K
K = np.sqrt(k**2 + kp**2 - 2 * k * kp *
(np.sqrt(1 - mu**2))) #changed K, correct one
#I=(1-mu**2) #in squeezed with original
#I=k*(k-2*kp*mu)*(1-mu**2)/K**2 #original I, without squeezed
#I=k*(k-2*kp*np.sqrt(1-mu**2))*(mu**2)/K**2 #I, without squeezed, changed, correct one
I = mu**2 #I, with squeezed, changed, correct one
integral = [
const * sp.integrate.trapz(sp.integrate.trapz(sp.integrate.trapz(
I * Mps_interpf(kp) * Mps_interpf(k) * (1 + z)**2 *
np.exp(-2 * tau_z) * f_z**2 * D_z**4 / chi_z**2 * H_z,
Mu,
axis=0),
Kp,
axis=0),
Z,
axis=0)
]
C_l = np.append(C_l, integral)
return C_l
def crosscorr_squeezedlim(ell,
y): #with the assumption that zi=z so no cos factor
z_i = 1.
delta_z = 0.3
n = 100
Mu = np.linspace(-0.9999, 0.9999, n)
Kp = np.linspace(1.e-4, 10., n)
mu, kp = np.meshgrid(Mu, Kp)
z = z_i
T_mean_zi = uf.T_mean(z_i)
chi_zi = chi(z_i)
chi_z = chi(z)
f_zi = uf.f(z_i)
f_z = uf.f(z)
D_zi = uf.D_1(z_i)
r_zi = uf.r(z_i)
D_z = uf.D_1(z)
H_zi = uf.H(z_i)
tau_z = uf.tau_inst(z)
const = 1.e6 / (
2. * np.pi
)**2 * T_rad * T_mean_zi / cc.c_light_Mpc_s * f_zi * D_zi**2 * H_zi / (
chi_zi**2 * r_zi) / (1. + z_i) * x * (
sigma_T * rho_g0 /
(mu_e * m_p)) * delta_z * f_z * D_z**2 * (1 + z) * np.exp(-tau_z)
#Cl=np.array([])
kpar = y / r_zi
k_perp = ell / chi_zi
k = np.sqrt(k_perp**2 + kpar**2)
rsd = 1. + f_zi * kpar**2 / k**2
theta_kp = kpar * mu / k + k_perp * np.sqrt(1. - mu**2) / k
integrand = Mps_interpf(kp) * rsd * theta_kp**2 * (
Mps_interpf(k)) #-mu*kp*np.gradient(Mps_interpf(k),axis=0))
integral_sing = const * sp.integrate.trapz(
sp.integrate.trapz(integrand, Mu, axis=0), Kp, axis=0)
#Cl=np.append(Cl,integral)
return integral_sing
def chi_check(z):
chi_der = cc.c_light_Mpc_s / uf.H(z)
chi = sp.integrate.trapz(chi_der, z)
return chi
T_rad = 2.73 #In Kelvin
chi_r = uf.chi(z_r)
chi_m = uf.chi(1100)
chi_min = 0.0001
k_min = 0.0001
k_max = 0.1
chi_array = np.linspace(chi_min, chi_m, n_points)
#tau_r=0.046*omega_b_0*h*x_e[np.sqrt(omega_M_0(1+z_r)**3+(1-omega_M_0))-1]
#get matter power spec data
f = uf.f(z_r)
#plt.loglog(uf.kabs,Mps_interpf(uf.kabs))
#plt.show()
const = (f * uf.H(z_r)) / cc.c_light_Mpc_s * T_rad
z = uf.z
zed = uf.zed
'''
delta_chi=chi_m-1.
g=((1.-np.exp(-tau_r))/np.sqrt(2*np.pi*(delta_chi)**2))*np.exp(-(chi-chi_r)**2/(2*(delta_chi)**2))
Integral_chip=sp.integrate.trapz(g,chi)
##print (Integral_chip,'chip')
g=g/chi**2
Integral_chi=sp.integrate.trapz(g,chi)
##print (Integral_chi,'chi')
'''
def y(z):
y = (1 + z)**(1.5)
