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)