def __init__(self, chi_min, chi_max, chi0, sigma_chi, cosmo_dict=None):
self.cosmo = cosmology.MultiEpoch(0.0, 5.0, cosmo_dict)
z_min = self.cosmo.redshift(chi_min)
z_max = self.cosmo.redshift(chi_max)
dNdz.__init__(self, chi_min, chi_max)
self.chi0 = chi0
self.sigma_chi = sigma_chi
def set_cosmology(self, cosmo_dict):
"""
Reset the cosmology
Args:
cosmo_dict: dictionary of floats defining a cosmology (see
defaults.py for details)
"""
self.initialized_spline = False
self.window_function_a.set_cosmology(cosmo_dict)
self.window_function_b.set_cosmology(cosmo_dict)
self.chi_min = self.window_function_a.chi_min
self.z_min = self.window_function_a.z_min
if self.window_function_b.chi_min < self.chi_min:
self.chi_min = self.window_function_b.chi_min
self.z_min = self.window_function_b.z_min
self.chi_max = self.window_function_a.chi_max
self.z_max = self.window_function_a.z_max
if self.window_function_b.chi_max > self.chi_max:
self.chi_max = self.window_function_b.chi_max
self.z_max = self.window_function_b.z_max
self.cosmo = cosmology.MultiEpoch(self.z_min, self.z_max, cosmo_dict)
self._find_z_bar()
def __init__(self,
ktheta_min,
ktheta_max,
window_function_a,
window_function_b,
cosmo_multi_epoch=None,
force_quad=False,
**kws):
self.initialized_spline = False
self.ln_ktheta_min = numpy.log(ktheta_min)
self.ln_ktheta_max = numpy.log(ktheta_max)
self.window_function_a = copy.copy(window_function_a)
self.window_function_b = copy.copy(window_function_b)
self.z_min = numpy.max(
[self.window_function_a.z_min, self.window_function_b.z_min])
self.z_max = numpy.min(
[self.window_function_a.z_max, self.window_function_b.z_max])
if cosmo_multi_epoch is None:
cosmo_multi_epoch = cosmology.MultiEpoch(self.z_min, self.z_max)
self.cosmo = cosmo_multi_epoch
self.window_function_a.set_cosmology_object(self.cosmo)
self.window_function_b.write('test_window_before')
self.window_function_b.set_cosmology_object(self.cosmo)
self.window_function_b.write('test_window_after')
self.chi_min = numpy.max([
defaults.default_precision["window_precision"],
self.cosmo.comoving_distance(self.z_min)
])
self.chi_max = self.cosmo.comoving_distance(self.z_max)
self._window_norm = integrate.romberg(
lambda chi: (self.window_function_a.window_function(chi) * self.
window_function_b.window_function(chi)),
self.chi_min,
self.chi_max,
vec_func=True,
tol=defaults.default_precision["global_precision"],
rtol=defaults.default_precision["kernel_precision"],
divmax=defaults.default_precision["divmax"])
self._ln_ktheta_array = numpy.linspace(
self.ln_ktheta_min, self.ln_ktheta_max,
defaults.default_precision["kernel_npoints"])
self._kernel_array = numpy.zeros_like(self._ln_ktheta_array,
dtype='float128')
self._j0_limit = special.jn_zeros(
0, defaults.default_precision["kernel_bessel_limit"])[-1]
self._force_quad = force_quad
self._find_z_bar()
def set_cosmology(self, cosmo_dict):
"""
Reset cosmology to values in cosmo_dict
Args:
cosmo_dict: dictionary of floats defining a cosmology. (see
defaults.py for details)
"""
self.cosmo = cosmology.MultiEpoch(self.z_min, self.z_max, cosmo_dict)
self.initialized_spline = False
def setUp(self):
lens_dist = kernel.dNdzMagLim(z_min=0.0, z_max=2.0,
a=1, z0=0.3, b=1)
source_dist = kernel.dNdzGaussian(z_min=0.0, z_max=2.0,
z0=1.0, sigma_z=0.2)
cosmo = cosmology.MultiEpoch(0.0, 5.0, cosmo_dict=c_dict)
self.lens_window = kernel.WindowFunctionGalaxy(
lens_dist, cosmo_multi_epoch=cosmo)
self.source_window = kernel.WindowFunctionConvergence(
source_dist, cosmo_multi_epoch=cosmo)
self.z_array = numpy.linspace(0.0, 2.0, 4)
def __init__(self, z_min, z_max, cosmo_multi_epoch=None, **kws):
self.initialized_spline = False
if z_min < defaults.default_precision['window_precision']:
z_min = defaults.default_precision['window_precision']
self.z_min = z_min
self.z_max = z_max
if cosmo_multi_epoch is None:
cosmo_multi_epoch = cosmology.MultiEpoch(z_min, z_max)
self.set_cosmology_object(cosmo_multi_epoch)
self._wf_array = numpy.zeros_like(self._chi_array, dtype='float128')
def __init__(self,
chi_min,
chi_max,
chi0,
sigma_chi,
cosmo_multi_epoch=None):
if cosmo_multi_epoch is None:
cosmo_multi_epoch = cosmology.MultiEpoch(0.0, 5.0)
self.cosmo = cosmo_multi_epoch
z_min = self.cosmo.redshift(chi_min)
z_max = self.cosmo.redshift(chi_max)
self.chi0 = chi0
self.sigma_chi = sigma_chi
dNdz.__init__(self, z_min, z_max)
def setUp(self):
cosmo = cosmology.MultiEpoch(0.0, 5.0, cosmo_dict=c_dict)
lens_dist = kernel.dNdzMagLim(z_min=0.0, z_max=2.0,
a=2, z0=0.3, b=2)
source_dist = kernel.dNdzGaussian(z_min=0.0, z_max=2.0,
z0=1.0, sigma_z=0.2)
lens_window = kernel.WindowFunctionGalaxy(
lens_dist, cosmo_multi_epoch=cosmo)
source_window = kernel.WindowFunctionConvergence(
source_dist, cosmo_multi_epoch=cosmo)
self.kern = kernel.Kernel(0.001*0.001*degToRad, 1.0*100.0*degToRad,
window_function_a=lens_window,
window_function_b=source_window,
cosmo_multi_epoch=cosmo)
self.ln_ktheta_array = numpy.linspace(-15, -1, 4)
def test_set_cosmology(self):
lens_window_list = [0.0, -13.999269, -13.306364, -12.901141]
source_window_list = [0.0, -16.011668, -15.318688, -14.913390]
cosmo = cosmology.MultiEpoch(0.0, 5.0, c_dict_2)
self.lens_window.set_cosmology_object(cosmo)
self.source_window.set_cosmology_object(cosmo)
for idx, z in enumerate(self.z_array):
self.assertAlmostEqual(
numpy.where(self.lens_window.window_function(z) > 0.0,
numpy.log(self.lens_window.window_function(z)),
0.0), lens_window_list[idx], p_dict["window"])
self.assertAlmostEqual(
numpy.where(self.source_window.window_function(z) > 1e-32,
numpy.log(self.source_window.window_function(z)),
0.0), source_window_list[idx], p_dict["window"])
def __init__(self,
ktheta_min,
ktheta_max,
window_function_a,
window_function_b,
cosmo_dict=None,
**kws):
self.initialized_spline = False
self.ln_ktheta_min = numpy.log(ktheta_min)
self.ln_ktheta_max = numpy.log(ktheta_max)
if cosmo_dict is None:
cosmo_dict = defaults.default_cosmo_dict
self.window_function_a = window_function_a
self.window_function_b = window_function_b
self.window_function_a.set_cosmology(cosmo_dict)
self.window_function_b.set_cosmology(cosmo_dict)
self.chi_min = self.window_function_a.chi_min
self.z_min = self.window_function_a.z_min
if self.window_function_b.chi_min < self.chi_min:
self.chi_min = self.window_function_b.chi_min
self.z_min = self.window_function_b.z_min
self.chi_max = self.window_function_a.chi_max
self.z_max = self.window_function_a.z_max
if self.window_function_b.chi_max > self.chi_max:
self.chi_max = self.window_function_b.chi_max
self.z_max = self.window_function_b.z_max
self.cosmo = cosmology.MultiEpoch(self.z_min, self.z_max, cosmo_dict)
self._ln_ktheta_array = numpy.linspace(
self.ln_ktheta_min, self.ln_ktheta_max,
defaults.default_precision["kernel_npoints"])
self._kernel_array = numpy.zeros_like(self._ln_ktheta_array)
self._j0_limit = special.jn_zeros(0, 4)[-1]
self._find_z_bar()
def cosmology_unit_test():
import cosmology
print "\n****************************"
print "* *"
print "* Testing Cosmology Module *"
print "* *"
print "****************************\n"
print "Testing Single Epoch"
print "****************************"
### Create single epoch cosmologies at the redshift specified
### outputs to stdout
cosmo = cosmology.SingleEpoch(redshift=0.0)
cosmo.write()
cosmo.set_redshift(redshift=0.5)
cosmo.write()
cosmo.set_redshift(redshift=1.0)
cosmo.write()
cosmo.set_redshift(redshift=2.0)
cosmo.write()
cosmo.set_redshift(redshift=3.0)
cosmo.write()
### Compute example multi epoch cosmologies from redshift z=0.0 to z=5.0
### output are the computed comoving distnace as a funciton of redshift and
### several other cosmological variables (Omega_m(z), Omega_L(z), etc.)
print "\nTesting Multi Epoch"
print "****************************"
cosmo = cosmology.MultiEpoch(z_min=0.0, z_max=5.0)
z = 0.0
print(
"Multi Epoch: (z, chi [Mpc/h], growth, omega_m(z), omega_l(z), "
"detla_c, delta_v, sigma_8)")
for z in [0.0, 0.5, 1.0, 2.0, 3.0]:
print(z, cosmo.comoving_distance(z), cosmo.growth_factor(z),
cosmo.omega_m(z), cosmo.omega_l(z), cosmo.delta_c(z),
cosmo.delta_v(z), cosmo.sigma_r(8.0, z))
print ""
def setUp(self):
cosmo_multi = cosmology.MultiEpoch(0.0, 5.0, cosmo_dict=c_dict)
lens_dist = kernel.dNdzMagLim(z_min=0.0, z_max=2.0,
a=2, z0=0.3, b=2)
source_dist = kernel.dNdzGaussian(z_min=0.0, z_max=2.0,
z0=1.0, sigma_z=0.2)
lens_window = kernel.WindowFunctionGalaxy(
lens_dist, cosmo_multi_epoch=cosmo_multi)
source_window = kernel.WindowFunctionConvergence(
source_dist, cosmo_multi_epoch=cosmo_multi)
kern = kernel.Kernel(0.001*0.001*deg_to_rad, 1.0*100.0*deg_to_rad,
window_function_a=lens_window,
window_function_b=source_window,
cosmo_multi_epoch=cosmo_multi)
zheng = hod.HODZheng(hod_dict)
cosmo_single = cosmology.SingleEpoch(0.0, cosmo_dict=c_dict)
h = halo.Halo(input_hod=zheng, cosmo_single_epoch=cosmo_single)
self.corr = correlation.Correlation(0.001, 1.0,
input_kernel=kern,
input_halo=h,
power_spec='power_mm')
self.theta_array = numpy.logspace(-3, 0, 4)*deg_to_rad
def kernel_unit_test():
import cosmology
import kernel
print "\n*************************"
print "* *"
print "* Testing kernel Module *"
print "* *"
print "*************************\n"
print "Testing dNdz"
print "*************************"
### To define a Kernel object we need several things first. We need redshift
### distributions as well as the corresponding window functions.
### initilized to galaxy redshift distributions one as a magnitude limited
### sample, the other a Guassian with mean z=1.0
lens_dist = kernel.dNdzMagLim(z_min=0.0, z_max=2.0, a=2, z0=0.3, b=2)
source_dist = kernel.dNdzGaussian(z_min=0.0,
z_max=2.0,
z0=1.0,
sigma_z=0.2)
### normalize the distributions and create PDFs
lens_dist.normalize()
source_dist.normalize()
z_array = numpy.linspace(0.0, 2.0, 5)
print "Lens dNdz: (z, p(z)dz)"
for z in z_array:
print "\t", (z, lens_dist.dndz(z))
print "Source dNdz: (z, p(z)dz)"
for z in z_array:
print "\t", (z, source_dist.dndz(z))
print ""
print "Testing WindowFunction"
print "*************************"
cosmo = cosmology.MultiEpoch(0.0, 2.0)
### using the distributions defined above compute the distance weighted
### window functions for use in projecting a powerspectrum
### Define a galaxy window function
chi_array = cosmo.comoving_distance(z_array)
lens_window = kernel.WindowFunctionGalaxy(redshift_dist=lens_dist)
print "Lens Window: (chi [Mpc/h], window value [h/Mpc])"
for chi in chi_array:
print "\t", (chi, lens_window.window_function(chi))
### Backup write command if more information is needed
# lens_window.write('test_galaxy_window_function.ascii')
### Define a lensed population of galaxies
source_window = kernel.WindowFunctionConvergence(redshift_dist=source_dist)
print "Source Window: (chi [Mpc/h], window value [h/Mpc])"
for chi in chi_array:
print "\t", (chi, source_window.window_function(chi))
### Backup write command if more information is needed
# source_window.write('test_convergence_window_function.ascii')
print "Testing Kernel"
print "*************************"
### Initialize the kernel objects for projecting a power spectrum in z space
### Initilize the kernel for galaxy clustering
ln_ktheta_array = numpy.linspace(-15, -1, 5)
k_Auto = kernel.Kernel(ktheta_min=0.001 * degToRad * 0.001,
ktheta_max=1.0 * degToRad * 100.0,
window_function_a=lens_window,
window_function_b=lens_window)
print "Auto Kernel: (k*theta [h/Mpc*Radians], kernel value [(h/Mpc)^2])"
for ln_ktheta in ln_ktheta_array:
print "\t", (numpy.exp(ln_ktheta), k_Auto.kernel(ln_ktheta))
### Backup write command if more information is needed
# k_Auto.write('test_clustering_kernel.ascii')
### Kernel computing lensing convergence
k_Con = kernel.Kernel(0.001 * degToRad * 0.001, 1.0 * degToRad * 100.0,
lens_window, source_window)
print(
"Convergence Kernel: (k*theta [h/Mpc*Radians], "
"kernel value [(h/Mpc)^2])")
for ln_ktheta in ln_ktheta_array:
print "\t", (numpy.exp(ln_ktheta), k_Con.kernel(ln_ktheta))
print ""
### Backup write command if more information is needed
# k_Con.write("test_convergence_kernel.ascii")
### Print out the redshifts for which the kernel is maximaly sensitive
print "Peak Sensitivity at Redshifts:", k_Auto.z_bar, k_Con.z_bar
"cmb_temp": 2.726,
"h": 0.7,
"sigma_8": 0.800,
"n_scalar": 0.960,
"w0": -1.0,
"wa": 0.0
}
cosmo_single_low = cosmology.SingleEpoch(redshift=0.1,
cosmo_dict=cosmo_dict,
with_bao=False)
cosmo_single = cosmology.SingleEpoch(redshift=3.0,
cosmo_dict=cosmo_dict,
with_bao=False)
cosmo_multi = cosmology.MultiEpoch(z_min=0.0,
z_max=5.0,
cosmo_dict=cosmo_dict,
with_bao=False)
halo_dict = {
"stq": 0.3,
"st_little_a": 0.707,
"c0": 9.,
"beta": -0.13,
"alpha": -1,
"delta_v": -1
}
mass_file_low = '/vol/fohlen11/fohlen11_1/bhernandez/chomp/mVector_PLANCK-SMT_z0.1.txt'
mass_low = mass_function.MassFunctionExternal(
mass_file_low,
redshift=0.1,
cosmo_single_epoch=cosmo_single_low,
def __init__(self,
ktheta_min,
ktheta_max,
window_function_a1,
window_function_a2,
window_function_b1,
window_function_b2,
cosmo_multi_epoch,
force_quad=False):
self.initialized_G_spline = False
self.initialized_NG_spline = False
self._initialized_ssc_spline = False
self._initialized_sigma2_spline = False
self.ln_ktheta_min = numpy.log(ktheta_min)
self.ln_ktheta_max = numpy.log(ktheta_max)
self.window_function_a1 = window_function_a1
self.window_function_a2 = window_function_a2
self.window_function_b1 = window_function_b1
self.window_function_b2 = window_function_b2
self.z_min = numpy.max([
self.window_function_a1.z_min, self.window_function_a2.z_min,
self.window_function_b1.z_min, self.window_function_b2.z_min
])
self.z_max = numpy.min([
self.window_function_a1.z_max, self.window_function_a2.z_max,
self.window_function_b1.z_max, self.window_function_b2.z_max
])
if cosmo_multi_epoch is None:
cosmo_multi_epoch = cosmology.MultiEpoch(self.z_min, self.z_max)
self.cosmo = cosmo_multi_epoch
self.window_function_a1.set_cosmology_object(self.cosmo)
self.window_function_a2.set_cosmology_object(self.cosmo)
self.window_function_b1.set_cosmology_object(self.cosmo)
self.window_function_b2.set_cosmology_object(self.cosmo)
self.chi_min = numpy.max([
defaults.default_precision["window_precision"],
self.cosmo.comoving_distance(self.z_min)
])
self.chi_max = self.cosmo.comoving_distance(self.z_max)
self._ln_ktheta_array = numpy.linspace(
self.ln_ktheta_min, self.ln_ktheta_max,
defaults.default_precision["kernel_npoints"])
self._kernel_array = numpy.empty(
(defaults.default_precision["kernel_npoints"],
defaults.default_precision["kernel_npoints"]), 'float128')
self._kernel_ssc_array = numpy.empty(
(defaults.default_precision["kernel_npoints"],
defaults.default_precision["kernel_npoints"]), 'float128')
self._j0_limit = special.jn_zeros(
0, defaults.default_precision["kernel_bessel_limit"])[-1]
self._j0_ssc_limit = special.jn_zeros(
0, int(defaults.default_precision["kernel_bessel_limit"] * 8))[-1]
self._j1_limit = special.jn_zeros(
1, defaults.default_precision['kernel_bessel_limit'])[-1]
self._force_quad = force_quad
### Forward declaration of our splines so we can call get/settatribute
self._kernel_G_spline = None
self._kernel_NG_spline = None
self._initialized_NG_spline = False
self._find_z_bar()
action="store",
type="str",
help="Name appended to output file")
parser.add_option("--alpha_norm",
dest="alpha_norm",
default=1.162,
action="store",
type="float",
help="Mag Normalization")
(options, args) = parser.parse_args()
z_array = numpy.array([0.474, 0.530, 0.590, 0.664, 0.750, 0.841, 0.955, 1.112])
z_bins = [[0.43, 0.5], [0.5, 0.56], [0.56, 0.63], [0.63, 0.7], [0.7, 0.79],
[0.79, 0.88], [0.88, 1.0], [1.0, 1.18]]
cosmo = cosmology.MultiEpoch(0, 5.01)
ratios = []
magnification = []
auto_corr = []
ratios = []
for bin, z in zip(z_bins, z_array):
print "Wtheta_F?p??_" + options.input_tag + '_z' + str(bin[0]) + str(
bin[1])
print "Wtheta_F?p??_auto_" + options.input_tag + '_z' + str(bin[0]) + str(
bin[1])
mag_name_list = numpy.sort(
glob("Wtheta_F?p??_" + options.input_tag + '_z' + str(bin[0]) +
str(bin[1]))).tolist()
auto_name_list = numpy.sort(
glob("Wtheta_F?p??_auto_" + options.input_tag + '_z' + str(bin[0]) +
def setUp(self):
self.cosmo = cosmology.MultiEpoch(0.0, 5.0, cosmo_dict=c_dict)