def test_power_sigma8norm_norms_consistent(tf): # make a cosmo with A_s cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=2e-9, n_s=0.96, transfer_function=tf) sigma8 = ccl.sigma8(cosmo) # remake same but now give sigma8 cosmo_s8 = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=sigma8, n_s=0.96, transfer_function=tf) # make sure they come out the same-ish assert np.allclose(ccl.sigma8(cosmo), ccl.sigma8(cosmo_s8)) # and that the power spectra look right a = 0.8 gfac = (ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_s8, a))**2 pk_rat = (ccl.linear_matter_power(cosmo, 1e-4, a) / ccl.linear_matter_power(cosmo_s8, 1e-4, a)) assert np.allclose(pk_rat, gfac)
def __init__(self, config): """ config - dict {'dtype': 'galaxy_density', 'seed': None, 'nside': ***, 'fsky': 0.2, 'cosmo': { 'Omega_c': 0.2640, 'Omega_b': 0.0493, 'h': 0.6736, 'n_s': 0.9649, 'sigma8': 0.8111, 'w0': -1, 'wa': 0, 'transfer_function': 'boltzmann_camb', 'baryons_power_spectrum': 'nobaryons' } 'zbin': 0, 'width': 0.5, } """ self._get_defaults(config) self.seed = self.config.get('seed', None) self.fsky = self.config.get('fsky', 0.2) cosmo = { # Planck 2018: Table 2 of 1807.06209 # Omega_m: 0.3133 'Omega_c': 0.2640, 'Omega_b': 0.0493, 'h': 0.6736, 'n_s': 0.9649, 'sigma8': 0.8111, 'w0': -1, 'wa': 0, 'transfer_function': 'boltzmann_camb', 'baryons_power_spectrum': 'nobaryons', } self.cosmo_pars = self.config.get('cosmo', cosmo) self.noise_level = self.config.get('noise_level', 0) self.cosmo = ccl.Cosmology(**self.cosmo_pars) ccl.sigma8(self.cosmo) self.dtype = self.config.get('dtype', 'galaxy_density') self._check_dtype() self.spin = self._get_spin_from_dtype(self.dtype) self.nmaps = 1 if self.spin: self.nmaps = 2 self.custom_auto = self.config.get('custom_auto', False) self.custom_offset = self.config.get('custom_offset', 0.) self.signal_map = None self.cl_coupled = None self.cls_cov = None self.nl_coupled = None self.mask = None self.dndz = None self.cl = None self.dec0 = self.config.get('dec0', 0.) self.ra0 = self.config.get('ra0', 0.) self.aposize = self.config.get('aposize', 1.)
def compute_cls(oc,ob,h,s8,ns,w,fname_out=False) : #Fiducial cosmological parameters cosmo=ccl.Cosmology(Omega_c=oc,Omega_b=ob,h=h,sigma8=s8,n_s=ns,w0=w, transfer_function='eisenstein_hu') print ccl.sigma8(cosmo) #Tracers tracers=[] for i in np.arange(nbins) : print i # tracers.append(ccl.ClTracer(cosmo,tracer_type='nc',z=zarr,n=nz_bins[i],bias=bzarr)) tracers.append(ccl.ClTracer(cosmo,tracer_type='wl',z=zarr,n=nz_bins[i]))#,bias=bzarr)) #Power spectra c_ij=np.zeros([LMAX+1,nbins,nbins]) for i1 in np.arange(nbins) : for i2 in np.arange(i1,nbins) : print i1,i2 if xcorr[i1,i2]<-1:#1E-6 : c_ij[:,i1,i2]=0 else : c_ij[:,i1,i2]=ccl.angular_cl(cosmo,tracers[i1],tracers[i2],np.arange(LMAX+1))#,l_limber=100) if i1!=i2 : c_ij[:,i2,i1]=c_ij[:,i1,i2] if fname_out!=False : np.save(fname_out,c_ij) return c_ij
def test_camb_class_consistent_smoke(kwargs=None, pkerr=1e-3): kwargs = kwargs or {} print('kwargs:', kwargs) c_camb = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, n_s=0.95, A_s=2e-9, transfer_function='boltzmann_camb', **kwargs) c_class = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, n_s=0.95, A_s=2e-9, transfer_function='boltzmann_class', **kwargs) rel_sigma8 = np.abs(ccl.sigma8(c_camb) / ccl.sigma8(c_class) - 1) a = 0.845 k = np.logspace(-3, 1, 100) pk_camb = ccl.linear_matter_power(c_camb, k, a) pk_class = ccl.linear_matter_power(c_class, k, a) rel_pk = np.max(np.abs(pk_camb / pk_class - 1)) print('rel err pk:', rel_pk) print('rel err sigma8:', rel_sigma8) assert rel_sigma8 < 3e-3 assert rel_pk < pkerr
def plot_model(ax, CBase, C, fmt, name): zar = np.linspace(0, 2.5, 100) aar = 1 / (1 + zar) f = ccl.growth_rate(C, aar) s8 = ccl.sigma8(C) * ccl.growth_factor(C, aar) f0 = ccl.growth_rate(CBase, aar) s80 = ccl.sigma8(CBase) * ccl.growth_factor(CBase, aar) ax.plot(zar, (f * s8) / (f0 * s80), fmt, label=name) return interp1d(zar, (s80 * f0))
def test_cosmo_methods(): """ Check that all pyccl functions that take cosmo as their first argument are methods of the Cosmology object. """ from inspect import getmembers, isfunction, signature from pyccl import background, bcm, boltzmann, \ cls, correlations, covariances, neutrinos, \ pk2d, power, tk3d, tracers, halos, nl_pt from pyccl.core import CosmologyVanillaLCDM cosmo = CosmologyVanillaLCDM() subs = [ background, boltzmann, bcm, cls, correlations, covariances, neutrinos, pk2d, power, tk3d, tracers, halos, nl_pt ] funcs = [getmembers(sub, isfunction) for sub in subs] funcs = [func for sub in funcs for func in sub] for name, func in funcs: pars = signature(func).parameters if list(pars)[0] == "cosmo": _ = getattr(cosmo, name) # quantitative assert ccl.sigma8(cosmo) == cosmo.sigma8() assert ccl.rho_x(cosmo, 1., "matter", is_comoving=False) == \ cosmo.rho_x(1., "matter", is_comoving=False) assert ccl.get_camb_pk_lin(cosmo).eval(1., 1., cosmo) == \ cosmo.get_camb_pk_lin().eval(1., 1., cosmo) prof = ccl.halos.HaloProfilePressureGNFW() hmd = ccl.halos.MassDef200m() hmf = ccl.halos.MassFuncTinker08(cosmo) hbf = ccl.halos.HaloBiasTinker10(cosmo) hmc = ccl.halos.HMCalculator(cosmo, massfunc=hmf, hbias=hbf, mass_def=hmd) assert ccl.halos.halomod_power_spectrum(cosmo, hmc, 1., 1., prof) == \ cosmo.halomod_power_spectrum(hmc, 1., 1., prof)
def S8z(mcmc, a, MG=False, size=None): p = mcmc.getParams() if size is None: size = p.A_s.size S8_ar = np.zeros((size, a.size)) for i in range(size): cosmo = ccl.Cosmology(h=p.h[i], Omega_c=p.Omega_c[i], Omega_b=p.Omega_b[i], A_s=1e-9 * p.A_s[i], n_s=p.n_s[i], w0=-1, wa=0, transfer_function='boltzmann_class') # Compute everything sigma8 = ccl.sigma8(cosmo) Dz = ccl.background.growth_factor(cosmo, a) Om = ccl.background.omega_x(cosmo, 1, 'matter') if MG: d1 = p.dpk1[i] else: d1 = 0 S8_ar[i] = (1 + d1 * (1 - a)) * Dz * sigma8 * (Om / 0.3)**0.5 return S8_ar
def test_power_mu_sigma_sigma8norm(tf): cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf) cosmo_musig = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf, mu_0=0.1, sigma_0=0.2) # make sure sigma8 is correct assert np.allclose(ccl.sigma8(cosmo_musig), 0.8) if tf != 'boltzmann_isitgr': # make sure P(k) ratio is right a = 0.8 gfac = ( ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_musig, a))**2 pk_rat = ( ccl.linear_matter_power(cosmo, 1e-4, a) / ccl.linear_matter_power(cosmo_musig, 1e-4, a)) assert np.allclose(pk_rat, gfac) with mock.patch.dict(sys.modules, {'isitgr': None}): with assert_raises(ImportError): get_isitgr_pk_lin(cosmo) # Importing ccl without isitgr is fine. No ImportError triggered. with mock.patch.dict(sys.modules, {'isitgr': None}): reload(ccl.boltzmann)
def main(): # zmins, zmaxs, fs8s, fs8errs = fig, ax = plt.subplots(figsize=(10, 3)) tc = thincandy.ThinCandy() basefs8 = plot_model(ax, tc.CBase, tc.CBase, "k:", "$\Lambda$CDM") if True: tc.getModels() plot_model(ax, tc.CBase, tc.Copen, "r--", "o$\Lambda$CDM") plot_model(ax, tc.CBase, tc.Cw, "g-.", "wCDM") plot_model(ax, tc.CBase, tc.Cmnu, "b-", "$\\nu$CDM") # plot_model(ax,tc.CBase,tc.Cmnuless, 'b:', "massles $\\nu$CDM") EdSP = tc.CBaseP EdSP["Omega_c"] = 1 - EdSP["Omega_b"] EdSP["sigma8"] = ccl.sigma8(tc.CBase) del EdSP["A_s"] plot_model(ax, tc.CBase, ccl.Cosmology(**EdSP), "m:", "EdS CDM") for zmin, zmax, fs8, fs8err in np.loadtxt("data/fs8.txt", usecols=(1, 2, 3, 4)): print(zmin, zmax, fs8, fs8err, 0.5 * (zmin + zmax)) zeff = 0.5 * (zmin + zmax) fs8 /= basefs8(zeff) fs8err /= basefs8(zeff) #ax.errorbar( # zeff, fs8, yerr=fs8err, xerr=(zmax - zmin) / 2, fmt="-", color="k", lw=1 #) ax.errorbar(zeff, fs8, yerr=fs8err, fmt="o-", color="k", lw=2) #ax.errorbar(zeff, fs8, yerr=fs8err, fmt="o", color="k", lw=2) # for zmin,zmax,val,errplus, errmin in np.loadtxt('data/wl.txt',usecols=(1,2,3,4,5)): # ## value is (Om/0.3)^1/2*sigma8 # baseval = np.sqrt(tc.CBase['Omega_m']/0.3)*ccl.sigma8(tc.CBase) # print (val,baseval,errplus) # zeff = np.sqrt((1+zmin)*(1+zmax))-1 # fs8eff = (ccl.growth_rate(tc.CBase,1/(1+zeff))* # ccl.sigma8(tc.CBase)*ccl.growth_factor(tc.CBase,1/(1+zeff)) ) # fact = fs8eff/baseval # val*=fact # errplus*=fact # errmin*=fact # ax.errorbar(zeff,val, yerr=([errmin],[errplus]), # xerr=([zeff-zmin],[zmax-zeff]),fmt='c',lw=1) # ax.errorbar(zeff,val, yerr=([errmin],[errplus]),fmt='oc',lw=2) # #ax.add_patch(Rectangle((zmin,val-errmin), zmax-zmin, errmin+errplus,color='blue',alpha=0.5)) ax.set_xlim(0, 2.5) ax.set_xlabel("$z$", fontsize=14) ax.set_ylim(0.4, 1.6) ax.set_ylabel("$f\,\sigma_8 / [f\,\sigma_8]_{\\rmfid}$", fontsize=14) plt.legend(fontsize=12, ncol=5, frameon=False, loc="upper center") plt.tight_layout() plt.savefig("output/thincandy_gr.pdf") plt.show()
def get_sigma_8(var): #Get cosmological parameters var_tot = get_cosmo(var) #Cosmology cosmo = ccl.Cosmology(h=var_tot[0], Omega_c=var_tot[1] / var_tot[0]**2., Omega_b=var_tot[2] / var_tot[0]**2., A_s=(10.**(-10.)) * np.exp(var_tot[3]), n_s=var_tot[4]) sigma8 = ccl.sigma8(cosmo) return sigma8
def compute_cls(oc,ob,h,s8,ns,w,nbins,zarr,nz_bins,lmax,fname_out=False) : cosmo=ccl.Cosmology(Omega_c=oc,Omega_b=ob,h=h,sigma8=s8,n_s=ns,w0=w)#,transfer_function='eisenstein_hu') print ccl.sigma8(cosmo) #Tracers tracers=[] for i in np.arange(nbins) : tracers.append(ccl.ClTracer(cosmo,tracer_type='wl',z=zarr,n=nz_bins[i])) #Power spectra c_ij=np.zeros([lmax+1,nbins,nbins]) for i1 in np.arange(nbins) : print i1 for i2 in np.arange(i1,nbins) : c_ij[:,i1,i2]=ccl.angular_cl(cosmo,tracers[i1],tracers[i2],np.arange(lmax+1))#,l_limber=100) if i1!=i2 : c_ij[:,i2,i1]=c_ij[:,i1,i2] if fname_out!=False : np.save(fname_out,c_ij) return c_ij
def test_camb_class_consistent_smoke(kwargs=None, pkerr=1e-3): kwargs = kwargs or {} print('kwargs:', kwargs) c_camb = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, n_s=0.95, A_s=2e-9, transfer_function='boltzmann_camb', **kwargs) c_class = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, n_s=0.95, A_s=2e-9, transfer_function='boltzmann_class', **kwargs) with warnings.catch_warnings(): # We do some tests here with massive neutrinos, which currently raises # a warning. # XXX: Do you really want to be raising a warning for this? # This seems spurious to me. (MJ) warnings.simplefilter("ignore") rel_sigma8 = np.abs(ccl.sigma8(c_camb) / ccl.sigma8(c_class) - 1) a = 0.845 k = np.logspace(-3, 1, 100) pk_camb = ccl.linear_matter_power(c_camb, k, a) pk_class = ccl.linear_matter_power(c_class, k, a) rel_pk = np.max(np.abs(pk_camb / pk_class - 1)) print('rel err pk:', rel_pk) print('rel err sigma8:', rel_sigma8) assert rel_sigma8 < 3e-3 assert rel_pk < pkerr
def calculate(self, state, want_derived=True, **params_values_dict): # Get background from upstream distance = self.provider.get_comoving_radial_distance(self.z_bg) hubble_z = self.provider.get_Hubble(self.z_bg) H0 = hubble_z[0] E_of_z = hubble_z / H0 distance = np.flip(distance) E_of_z = np.flip(E_of_z) # Translate into CCL parameters h = H0 * 0.01 Omega_c = self.provider.get_param('omch2') / h**2 Omega_b = self.provider.get_param('ombh2') / h**2 # Generate cosmology and populate background a = 1. / (1 + self.z_bg[::-1]) cosmo = ccl.Cosmology(Omega_c=Omega_c, Omega_b=Omega_b, h=h, n_s=self.provider.get_param('ns'), A_s=self.provider.get_param('As'), T_CMB=2.7255, m_nu=self.provider.get_param('mnu'), transfer_function=self.transfer_function, matter_power_spectrum=self.matter_pk, baryons_power_spectrum=self.baryons_pk) cosmo._set_background_from_arrays(a_array=a, chi_array=distance, hoh0_array=E_of_z) # Populate P(k) if self.kmax: for pair in self._var_pairs: k, z, Pk_lin = self.provider.get_Pk_grid(var_pair=pair, nonlinear=False) Pk_lin = np.flip(Pk_lin, axis=0) a = 1. / (1 + np.flip(z)) cosmo._set_linear_power_from_arrays(a, k, Pk_lin) if self.external_nonlin_pk: k, z, Pk_nl = self.provider.get_Pk_grid(var_pair=pair, nonlinear=True) Pk_nl = np.flip(Pk_nl, axis=0) a = 1. / (1 + np.flip(z)) cosmo._set_nonlin_power_from_arrays(a, k, Pk_nl) state['CCL'] = {'cosmo': cosmo} # Compute sigma8 (we should actually only do this if required -- TODO) state['sigma8'] = ccl.sigma8(cosmo) for req_res, method in self._required_results.items(): state['CCL'][req_res] = method(cosmo)
def check_power(cosmo): """ Check that power spectrum and sigma functions can be run. """ # Types of scale factor a = 0.9 a_arr = np.linspace(0.2, 1., 5) # Types of wavenumber input (scalar, list, array) k_scl = 1e-1 k_lst = [1e-4, 1e-3, 1e-2, 1e-1, 1e0] k_arr = np.logspace(-4., 0., 5) # Types of smoothing scale, R R_scl = 8. R_lst = [1., 5., 10., 20., 50., 100.] R_arr = np.array([1., 5., 10., 20., 50., 100.]) # linear_matter_power assert_(all_finite(ccl.linear_matter_power(cosmo, k_scl, a))) assert_(all_finite(ccl.linear_matter_power(cosmo, k_lst, a))) assert_(all_finite(ccl.linear_matter_power(cosmo, k_arr, a))) assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_scl, a_arr) assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_lst, a_arr) assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_arr, a_arr) # nonlin_matter_power assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_scl, a))) assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_lst, a))) assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_arr, a))) assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_scl, a_arr) assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_lst, a_arr) assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_arr, a_arr) # sigmaR assert_(all_finite(ccl.sigmaR(cosmo, R_scl))) assert_(all_finite(ccl.sigmaR(cosmo, R_lst))) assert_(all_finite(ccl.sigmaR(cosmo, R_arr))) # sigmaV assert_(all_finite(ccl.sigmaV(cosmo, R_scl))) assert_(all_finite(ccl.sigmaV(cosmo, R_lst))) assert_(all_finite(ccl.sigmaV(cosmo, R_arr))) # sigma8 assert_(all_finite(ccl.sigma8(cosmo)))
def calculate(self, state, want_derived=True, **params_values_dict): # Generate the CCL cosmology object which can then be used downstream cosmo = ccl.Cosmology(Omega_c=self.provider.get_param('Omega_c'), Omega_b=self.provider.get_param('Omega_b'), h=self.provider.get_param('h'), n_s=self.provider.get_param('n_s'), A_s=self.provider.get_param('A_sE9') * 1E-9, T_CMB=2.7255, m_nu=self.provider.get_param('m_nu'), transfer_function=self.transfer_function, matter_power_spectrum=self.matter_pk, baryons_power_spectrum=self.baryons_pk) state['CCL'] = {'cosmo': cosmo} # Compute sigma8 (we should actually only do this if required -- TODO) state['sigma8'] = ccl.sigma8(cosmo) for req_res, method in self._required_results.items(): state['CCL'][req_res] = method(cosmo)
def test_power_mu_sigma_sigma8norm(tf): cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf) cosmo_musig = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf, mu_0=0.1, sigma_0=0.2) # make sure sigma8 is correct assert np.allclose(ccl.sigma8(cosmo_musig), 0.8) # make sure P(k) ratio is right a = 0.8 gfac = ( ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_musig, a))**2 pk_rat = ( ccl.linear_matter_power(cosmo, 1e-4, a) / ccl.linear_matter_power(cosmo_musig, 1e-4, a)) assert np.allclose(pk_rat, gfac)
import pyccl as ccl cosmo = ccl.Cosmology( Omega_c=0.25, Omega_b=0.05, h=0.7, n_s=0.95, A_s=2.1e-9, transfer_function="boltzmann_camb", ) print("sigma8:", ccl.sigma8(cosmo)) assert ccl.sigma8(cosmo) > 0.82 and ccl.sigma8(cosmo) < 0.825
def fs8(self, C): fs8 = ccl.growth_rate(C, self.aar) * ccl.sigma8(C) fs80 = ccl.growth_rate(self.CBase, self.aar) * ccl.sigma8(self.CBase) return fs8 / fs80
def calculate(self, state, want_derived=True, **params_values_dict): # Get background from upstream distance = self.provider.get_comoving_radial_distance(self.z_bg) hubble_z = self.provider.get_Hubble(self.z_bg) H0 = hubble_z[0] E_of_z = hubble_z / H0 distance = np.flip(distance) E_of_z = np.flip(E_of_z) # Translate into CCL parameters h = H0 * 0.01 Omega_c = self.provider.get_param('omch2') / h**2 Omega_b = self.provider.get_param('ombh2') / h**2 # Generate cosmology and populate background a_bg = 1. / (1 + self.z_bg[::-1]) if self.kmax: pkln = {} if self.external_nonlin_pk: pknl = {} for pair in self._var_pairs: name = self._translate_camb(pair) k, z, Pk_lin = self.provider.get_Pk_grid(var_pair=pair, nonlinear=False) Pk_lin = np.flip(Pk_lin, axis=0) a = 1. / (1 + np.flip(z)) pkln[name] = Pk_lin pkln['a'] = a pkln['k'] = k if self.external_nonlin_pk: k, z, Pk_nl = self.provider.get_Pk_grid(var_pair=pair, nonlinear=True) Pk_nl = np.flip(Pk_nl, axis=0) a = 1. / (1 + np.flip(z)) pknl[name] = Pk_nl pknl['a'] = a pknl['k'] = k cosmo = ccl.CosmologyCalculator( Omega_c=Omega_c, Omega_b=Omega_b, h=h, n_s=self.provider.get_param('ns'), A_s=self.provider.get_param('As'), T_CMB=2.7255, m_nu=self.provider.get_param('mnu'), background={ 'a': a_bg, 'chi': distance, 'h_over_h0': E_of_z }, pk_linear=pkln, pk_nonlin=pknl) else: cosmo = ccl.CosmologyCalculator( Omega_c=Omega_c, Omega_b=Omega_b, h=h, n_s=self.provider.get_param('ns'), A_s=self.provider.get_param('As'), T_CMB=2.7255, m_nu=self.provider.get_param('mnu'), background={ 'a': a_bg, 'chi': distance, 'h_over_h0': E_of_z }) state['CCL'] = {'cosmo': cosmo} # Compute sigma8 (we should actually only do this if required -- TODO) state['sigma8'] = ccl.sigma8(cosmo) for req_res, method in self._required_results.items(): state['CCL'][req_res] = method(cosmo)
def bgplot(self): print(ccl.sigma8(self.CBase), self.rd(self.CBase)) print("getting open") # [(aiso,'isotropic BAO'), (aperp, 'transverse BAO'), (apar, #'radial BAO'), (sn, 'SN distance '), (fs8, 'fsigma8'), # (shearshear, 'WL shear auto')]): self.getModels() f, axl = plt.subplots( 3, 2, facecolor="w", gridspec_kw={ "width_ratios": (3, 1), "hspace": 0.0, "wspace": 0.05 }, figsize=(10, 6), ) print(axl) # [(self.aiso,'BAO $\\bigcirc$'), for i, ((fun, name), (axl, axr)) in enumerate( zip( [ (self.aperp, "BAO $\perp$"), (self.apar, "BAO $\parallel$"), (self.sn, "SN"), ], axl, )): for model, label, style in [ (self.CBase, "LCDM", "k:"), (self.Copen, "OLCDM", "r--"), (self.Cw, "wCDM", "g-."), (self.Cmnu, "$\\nu$CDM", "b-"), ]: vals = fun(model) axl.plot(self.zar[:self.Nl], vals[:self.Nl], style, label=label) axr.plot(self.zar[-self.Nr:], vals[-self.Nr:], style) if "perp" in name: for zb, iso, isoe, perp, perpe, par, pare in self.baodata: axr.errorbar(1150, 1, yerr=0.000605211, fmt="ko") if perp > 0: norm = ccl.comoving_angular_distance( self.CBase, 1 / (1 + zb)) / self.rd(self.CBase) # print (zb,norm,perp,perpe,perp/norm,perpe/norm) axl.errorbar(zb, perp / norm, yerr=perpe / norm, fmt="ko") if iso > 0: print(self.rd(self.CBase)) normperp = ccl.comoving_angular_distance( self.CBase, 1 / (1 + zb)) / self.rd(self.CBase) normpar = 299792.45 / (ccl.h_over_h0( self.CBase, 1 / (1 + zb)) * self.CBase["H0"] * self.rd(self.CBase)) norm = (zb * normpar)**(1 / 3) * normperp**(2 / 3) axl.errorbar(zb, iso / norm, yerr=isoe / norm, fmt="ko") elif "par" in name: for zb, iso, isoe, perp, perpe, par, pare in self.baodata: if par > 0: norm = 299792.45 / (ccl.h_over_h0( self.CBase, 1 / (1 + zb)) * self.CBase["H0"] * self.rd(self.CBase)) # print (zb,norm,par,pare,par/norm,pare/norm) axl.errorbar(zb, par / norm, yerr=pare / norm, fmt="ko") elif "SN" in name: axl.errorbar(self.snz, self.snval, yerr=self.snerr, fmt="ko") if i == 1: axl.legend(fontsize=12, ncol=2, frameon=False, loc="lower center") axl.set_ylabel(name, fontsize=14) axl.spines["right"].set_visible(False) axr.spines["left"].set_visible(False) # axl.yaxis.tick_left() # axl.tick_params(labelright='off') axl.tick_params(axis="x", direction="inout", length=5) axr.tick_params(axis="x", direction="inout", length=5) axl.patch.set_alpha(0.0) axr.patch.set_alpha(0.0) axl.set_xlim(0.0, 3.1) axr.set_xlim(1100, 1200) axr.set_xticks([1120, 1200]) if i < 2: axl.set_ylim(0.85, 1.15) axl.set_yticks([0.90, 1.0, 1.1]) else: axl.set_ylim(0.8, 1.2) axl.set_yticks([0.9, 1.0, 1.1]) if i == 0: axr.set_ylim(0.995, 1.005) axr.set_yticks([0.997, 1.0, 1.003]) elif i == 1: axr.set_ylim(0.995, 1.005) axr.set_yticks([0.997, 1.0, 1.003]) elif i == 2: axr.set_ylim(0.8, 1.2) axr.set_yticks([0.9, 1.0, 1.1]) if i < 2: for l in axl.get_xticklabels(): l.set_visible(False) for l in axr.get_xticklabels(): l.set_visible(False) for l in axr.get_yticklabels(): l.set_visible(False) axr.get_yaxis().tick_right() # set_visible(False) d = 0.05 kwargs = dict(transform=axl.transAxes, color="k", clip_on=False) axl.plot((1 - d / 5, 1 + d / 5), (-d, +d), **kwargs) axl.plot((1 - d / 5, 1 + d / 5), (1 - d, 1 + d), **kwargs) kwargs = dict(transform=axr.transAxes, color="k", clip_on=False) axr.plot((-d * 3 / 5, +d * 3 / 5), (-d, +d), **kwargs) axr.plot((-d * 3 / 5, +d * 3 / 5), (1 - d, 1 + d), **kwargs) if i == 2: axl.set_xlabel("$z$", fontsize=14) # plt.tight_layout() plt.savefig(f"output/thincandy_bg.pdf") plt.show()
plt.loglog(k, Pk_nonlin, 'g', linewidth=2, label='Non-linear (halofit)') plt.loglog(k, Pk_baryon, 'm', linewidth=2, linestyle=':', label='With baryonic correction') plt.loglog(k, Pk_emu, 'b', linewidth=2, linestyle = '--', label='CosmicEmu') plt.xlabel('$k, \\frac{1}{\\rm Mpc}$', fontsize=20) plt.ylabel('$P(k), {\\rm Mpc^3}$', fontsize=20) plt.xlim(0.001, 50) plt.ylim(0.01, 10**6) plt.tick_params(labelsize=13) plt.legend(loc='lower left') plt.show() plt.close() R = np.linspace(5, 20, 15) sigmaR = ccl.sigmaR(cosmo, R) sigma8 = ccl.sigma8(cosmo) print("sigma8 =", sigma8) # ############### # Can also compute C_ell for galaxy counts, galaxy lensing and CMB lensing # for autocorrelations or any cross-correlation z_pz = np.linspace(0.3, 3., 3) # Define the edges of the photo-z bins. # array([0.3 , 1.65, 3. ]) AKA 2 bins pz = ccl.PhotoZGaussian(sigma_z0=0.05) def dndz(z,args) : return z**2*np.exp(-(z/0.5)**1.5) redshift_dist=ccl.dNdzFunction(dndz)
#Calculate the matter power spectrum k = np.logspace(-4., 1., 100) #Wavenumber a = 1. #Scale factor #Matter power spectrum, lin and nonlin pk_lin = np.asarray(ccl.linear_matter_power(cosmo, k, a)) pk_nl = np.asarray(ccl.nonlin_matter_power(cosmo, k, a)) plt.plot(k, pk_lin, 'b-') plt.plot(k, pk_nl, 'r-') plt.xscale('log') plt.yscale('log') plt.savefig('power_spectrum.png', format='png') #Transforms these to lists k = k.tolist() pk_lin = pk_lin.tolist() pk_nl = pk_nl.tolist() #Adds a header line k = ['k'] + k pk_lin =['pk lin'] + pk_lin pk_nl = ['pk_nl'] + pk_nl np.savetxt('power_spec.dat', np.transpose([k, pk_lin, pk_nl]), fmt='%-20s') #Get the power spectrum normalization, sigma_8 normal = ccl.sigma8(cosmo) pdb.set_trace()
def test_sigma8_consistent(): assert np.allclose(ccl.sigma8(COSMO), COSMO['sigma8']) assert np.allclose(ccl.sigmaR(COSMO, 8 / COSMO['h'], 1), COSMO['sigma8'])