def get_bao_rs_dV(zs,params=None,engine='camb',de='ppf'): #FIXME: camb and class only agree at 3% level!!! import camb params = map_params(params,engine=engine) if engine=='camb': pars = set_camb_pars(params=params,de=de) results = camb.get_results(pars) retval = results.get_BAO(zs,pars)[:,0] elif engine=='class': from classy import Class zs = np.asarray(zs) cosmo = Class() params['output'] = '' cosmo.set(params) cosmo.compute() Hzs = np.array([cosmo.Hubble(z) for z in zs]) D_As = np.array([cosmo.angular_distance(z) for z in zs]) D_Vs = ((1+zs)**2 * D_As**2 * zs/Hzs)**(1/3.) retval = cosmo.rs_drag()/D_Vs cosmo.struct_cleanup() cosmo.empty() return retval
# (but not exactly zero because we neglected radiation) derived = CDM.get_current_derived_parameters(['Omega0_lambda']) print derived print "Omega_Lambda =", derived['Omega0_lambda'] # In[ ]: #Get background quantities and recover their names: baLCDM = LCDM.get_background() baCDM = CDM.get_background() baCDM.viewkeys() # In[ ]: #Get H_0 in order to plot the distances in this unit fLCDM = LCDM.Hubble(0) fCDM = CDM.Hubble(0) # In[ ]: namelist = ['lum. dist.', 'comov. dist.', 'ang.diam.dist.'] colours = ['b', 'g', 'r'] for name in namelist: idx = namelist.index(name) plt.loglog(baLCDM['z'], fLCDM * baLCDM[name], colours[idx] + '-') plt.legend(namelist, loc='upper left') for name in namelist: idx = namelist.index(name) plt.loglog(baCDM['z'], fCDM * baCDM[name], colours[idx] + '--') plt.xlim([0.07, 10]) plt.ylim([0.08, 20])
print('rd=', rd) for j in range(len(chunk)): z = zs[j] b1 = b1ar[j] b2 = b2ar[j] bG2 = bG2ar[j] css0 = css0ar[j] css2 = css2ar[j] Pshot = Pshotar[j] bGamma3 = bGamma3ar[j] b4 = b4ar[j] fz = cosmo.scale_independent_growth_factor_f(z) da = cosmo.angular_distance(z) # print('DA=',da) hz = cosmo.Hubble(z) / kmsMpc # print('Hz=',hz) DV = (z * (1 + z)**2 * da**2 / cosmo.Hubble(z))**(1. / 3.) # print('DV=',DV) fs8 = cosmo.scale_independent_growth_factor( z) * cosmo.scale_independent_growth_factor_f(z) * cosmo.sigma8() # print('fs8=',fs8) # print('sigma8=',cosmo.sigma8()) print('rd/DV=', rd / DV) print('rdH=', rd * cosmo.Hubble(z)) print('rd/DA=', rd / da) P2noW = np.zeros(k_size) P0noW = np.zeros(k_size) for i in range(k_size): kinloop1 = k[i] * h
from classy import Class cosmo = Class() cosmo.set({'N_eff': 3.046, 'output': 'tCl'}) print(cosmo.Hubble(0))
bg_t = background['proper time [Gyr]'][::-1] bg_H = background['H [1/Mpc]'][::-1] bg_D = background['gr.fac. D'][::-1] bg_f = background['gr.fac. f'][::-1] bg_z = background['z'][::-1] bg_a = 1. / (1 + bg_z) bg_rho = background['(.)rho_tot'][::-1] bg_p = background['(.)p_tot'][::-1] #Size of arrays of background quantities nz = 1000 zmax = max(1000, z_f * 1.05, z_i * 1.05) zmin = 0 #Curvature parameter K = -cosmo.Omega0_k() * cosmo.Hubble(0)**2 #Compute conformal derivative of the Hubble rate bg_H_prime = -1.5 * (bg_rho + bg_p) * bg_a + K / bg_a bg_H_dot = bg_H_prime / bg_a bg_Hdot_over_H2 = bg_H_dot / bg_H**2 #Normalize the growth factor # z_norm = z_f # D_norm = cosmo.scale_independent_growth_factor(z_norm) # a_norm = 1./(1+z_norm) # bg_D = bg_D/D_norm #Compute central difference derivative of the logarithmic growth rate bg_df_dlogD = np.gradient(bg_f) / np.gradient(np.log(bg_D))
def calculate_derivative_param(params, param_to_test, param_fiducial, percentage_difference, param_list, der_param, write_file, i): cosmo = Class() # Create an instance of the CLASS wrapper param = np.zeros((N, 3, len(param_list))) for j in range(3): # going over a_c and Om_fld values # if j==0: # params['Omega_fld_ac'] = Omega_ac_fid[i] # if j==1: # params['Omega_fld_ac'] = Omega_ac_fid[i]+percentage_difference*Omega_ac_fid[i] # if j==2: # params['Omega_fld_ac'] = Omega_ac_fid[i]-percentage_difference*Omega_ac_fid[i] if param_to_test == 'scf_parameters': if j == 0: params['scf_parameters'] = '%.5f,0.0' % (param_fiducial) if j == 1: params['scf_parameters'] = '%.5f,0.0' % ( param_fiducial + percentage_difference * param_fiducial) if j == 2: params['scf_parameters'] = '%.5f,0.0' % ( param_fiducial - percentage_difference * param_fiducial) else: if j == 0: params[param_to_test] = param_fiducial if j == 1: params[ param_to_test] = param_fiducial + percentage_difference * param_fiducial if j == 2: params[ param_to_test] = param_fiducial - percentage_difference * param_fiducial # if j==0: # params['Omega_many_fld'] = Omega0_fld # if j==1: # params['Omega_many_fld'] = Omega0_fld+percentage_difference*Omega0_fld # if j==2: # params['Omega_many_fld'] = Omega0_fld-percentage_difference*Omega0_fld print params[param_to_test], param_fiducial # try to solve with a certain cosmology, no worries if it cannot # l_theta_s = np.pi/(theta_s) # print "here:",l_theta_s # try: cosmo.set(params) # Set the parameters to the cosmological code cosmo.compute() # solve physics cl = cosmo.lensed_cl(2500) ell = cl['ell'][2:] tt = cl['tt'][2:] fTT = interp1d(ell, tt * ell * (ell + 1)) for k in range(len(param_list)): print 'k', k, len(param_list) #calculate height peak difference if (param_list[k] == 'HP'): # param[i][j][k] = max(tt)-fTT(10) param[i][j][k] = max(tt * ell * (ell + 1)) elif (param_list[k] == 'rs_rec'): param[i][j][k] = cosmo.rs_rec() elif (param_list[k] == 'rd_rec'): param[i][j][k] = cosmo.rd_rec() elif (param_list[k] == 'rs_rec_over_rd_rec'): # print cosmo.rs_rec()/cosmo.rd_rec() param[i][j][k] = cosmo.rs_rec() / cosmo.rd_rec() elif (param_list[k] == 'da_rec'): param[i][j][k] = cosmo.da_rec() elif (param_list[k] == 'theta_s'): param[i][j][k] = cosmo.theta_s() elif (param_list[k] == 'H0'): param[i][j][k] = cosmo.Hubble(0) print max(tt * ell * (ell + 1)), cosmo.theta_s(), cosmo.da_rec( ), cosmo.rs_rec(), cosmo.z_rec() # for l in range(len(tt)): # # print l, tt[l], max(tt*ell*(ell+1)) # if tt[l]*ell[l]*(ell[l]+1) == max(tt*ell*(ell+1)): # print "l:", l,max(tt*ell*(ell+1)) # except CosmoComputationError: # this happens when CLASS fails # print CosmoComputationError # pass # eh, don't do anything #calculate derivative # der_HP[i]= (HP[i][1]-HP[i][2])/(Omega_ac_fid[i]+percentage_difference*Omega_ac_fid[i]-(Omega_ac_fid[i]-percentage_difference*Omega_ac_fid[i]))*Omega_ac_fid[0]/HP[i][0] cosmo.empty() cosmo.struct_cleanup() if write_file == True: f.write(str(ac_values[i]) + '\t\t') print "calculating derivative" for k in range(len(param_list)): # der_HP[i]= (HP[i][1]-HP[i][2])/(fraction_fiducial+percentage_difference*fraction_fiducial-(fraction_fiducial-percentage_difference*fraction_fiducial))*fraction_fiducial/HP[i][0] der_param[i][k] = (param[i][1][k] - param[i][2][k]) / ( param_fiducial + percentage_difference * param_fiducial - (param_fiducial - percentage_difference * param_fiducial) ) * param_fiducial / param[i][0][k] if write_file == True: f.write(str(der_param[i][k]) + '\t\t') # info on format print param_list[k], der_param[i][k] if write_file == True: f.write('\n') return
def constraints(params, zs): cosmo = Class() cosmo.set(params) cosmo.compute() h = cosmo.Hubble(0) * 299792.458 om0 = cosmo.Omega0_m() #print(cosmo.pars) zarr2 = cosmo.get_background().get('z') hz = cosmo.get_background().get('H [1/Mpc]') hf = interpolate.InterpolatedUnivariateSpline(zarr2[-1:0:-1], hz[-1:0:-1]) chiz = cosmo.get_background().get('comov. dist.') chif = interpolate.InterpolatedUnivariateSpline(zarr2[-1:0:-1], chiz[-1:0:-1]) pkz = np.zeros((nk, nz)) pklz2 = np.zeros((nk, nz)) dprime = np.zeros((nk, 1)) zarr = np.linspace(0, zmax, nz) karr = np.logspace(-3, np.log10(20), nk) rcollarr = np.zeros(nz) kcarr = np.zeros(nz) delz = 0.01 for i in np.arange(nz): Dz = (cosmo.scale_independent_growth_factor(zarr[i]) / cosmo.scale_independent_growth_factor(0)) sigz = lambda x: Dz * cosmo.sigma(x, zarr[i]) - 1.192182033080519 if (sigz(1e-5) > 0) & (sigz(10) < 0): rcollarr[i] = optimize.brentq(sigz, 1e-5, 10) else: rcollarr[i] = 0 for j in np.arange(nk): pkz[j, i] = cosmo.pk(karr[j], zarr[i]) for i in np.arange(nk): pklz0 = np.log(cosmo.pk(karr[i], zs - delz) / cosmo.pk(karr[i], 0)) pklz1 = np.log(cosmo.pk(karr[i], zs + delz) / cosmo.pk(karr[i], 0)) pklz2[i] = cosmo.pk(karr[i], 0) dprime[i] = -hf(zs) * np.sqrt( cosmo.pk(karr[i], zs) / pklz2[i, 0]) * (pklz1 - pklz0) / 4 / delz #divided by 2 for step size, another for defining D' w0 = params.get('w0_fld') wa = params.get('wa_fld') mt = 5 * np.log10(cosmo.luminosity_distance(zs)) #mt = 5*np.log10(fanal.dlatz(zs, om0, og0, w0, wa)) Rc = (2 * 4.302e-9 * Mc / h**2 / om0)**(1 / 3) mask = (0 < rcollarr) & (rcollarr < Rc) kcarr[mask] = 2 * np.pi / rcollarr[mask] mask = (rcollarr >= Rc) kcarr[mask] = 2 * np.pi / Rc #plt.semilogy(zarr, kcarr) pksmooth = pdf.pkint(karr, zarr, pkz, kcarr) par2 = {'w0': w0, 'wa': wa, 'Omega_m': om0} print(par2) #kmin = conv.kmin(zs, chif, hf)*(-3./2.*hf(0)**2*om0) kvar = conv.kvar(zs, pksmooth, chif, hf) * (3. / 2. * hf(0)**2 * om0)**2 #sigln = np.log(1+kvar/np.abs(kmin)**2) #L = pdf.convpdf(kmin, sigln, sig, mfid-mt) #sigln = np.sqrt(sig**2+(5/np.log(10))**2*kvar) #L = pdf.gausspdf(sig, mfid-mt) #lnL = mt/sig vvar = np.trapz(pklz2[:, 0] * dprime[:, 0]**2, karr) / 6 / np.pi**2 * (1 - (1 + zs) / hf(zs) / chif(zs))**2 #var_tot = norm*kvar+sig**2 lnL = -mt**2 / 2 print('Sigmasq = {}, {}, Likelihood = {}'.format(kvar, vvar, lnL)) cosmo.struct_cleanup() cosmo.empty() return [mt, kvar, vvar] #[mt, var_tot]
class classy(SlikPlugin): """ Compute the CMB power spectrum with CLASS. Based on work by: Brent Follin, Teresa Hamill """ #{cosmoslik name : class name} name_mapping = { 'As': 'A_s', 'lmax': 'l_max_scalars', 'mnu': 'm_ncdm', 'Neff': 'N_ncdm', 'ns': 'n_s', 'nt': 'n_t', 'ombh2': 'omega_b', 'omch2': 'omega_cdm', 'omk': 'Omega_k', 'pivot_scalar': 'k_pivot', 'r': 'r', 'tau': 'tau_reio', 'Tcmb': 'T_cmb', 'Yp': 'YHe', } def __init__(self, **defaults): super().__init__() from classy import Class self.model = Class() self.defaults = defaults def convert_params(self, **params): """ Convert from CosmoSlik params to CLASS """ params = {self.name_mapping.get(k, k): v for k, v in params.items()} if 'theta' in params: params['100*theta_s'] = 100 * params.pop('theta') params['lensing'] = 'yes' if params.pop('DoLensing', True) else 'no' return params def __call__(self, As=None, DoLensing=True, H0=None, lmax=None, mnu=None, Neff=None, nrun=None, ns=None, ombh2=None, omch2=None, omk=None, output='tCl, lCl, pCl', pivot_scalar=None, r=None, tau=None, Tcmb=2.7255, theta=None, w=None, Yp=None, nowarn=False, **kwargs): if not nowarn and kwargs: print('Warning: passing unknown parameters to CLASS: ' + str(kwargs) + ' (set nowarn=True to turn off this message.)') params = dict( self.defaults, **{ k: v for k, v in arguments(include_kwargs=False, exclude=["nowarn"]).items() if v is not None }) self.model.set(self.convert_params(**params)) self.model.compute() lmax = params['lmax'] ell = arange(lmax + 1) if params['DoLensing'] == True: self.cmb_result = { x: (self.model.lensed_cl(lmax)[x.lower()]) * Tcmb**2 * 1e12 * ell * (ell + 1) / 2 / pi for x in ['TT', 'TE', 'EE', 'BB', 'PP', 'TP'] } else: self.cmb_result = { x: (self.model.raw_cl(lmax)[x.lower()]) * Tcmb**2 * 1e12 * ell * (ell + 1) / 2 / pi for x in ['TT'] } self.model.struct_cleanup() self.model.empty() return self.cmb_result def get_bao_observables(self, z): return { 'H': self.model.Hubble(z), 'D_A': self.model.angular_distance(z), 'c': 1.0, 'r_d': (self.model.get_current_derived_parameters(['rs_rec']))['rs_rec'] }