def testInstances(self):
pars = camb.set_params(H0=69.1, ombh2=0.032, omch2=0.122, As=3e-9, ns=0.91, omk=0.013,
redshifts=[0.], kmax=0.5)
data = camb.get_background(pars)
res1 = data.angular_diameter_distance(0.7)
drag1 = data.get_derived_params()['rdrag']
pars2 = camb.set_params(H0=65, ombh2=0.022, omch2=0.122, As=3e-9, ns=0.91)
data2 = camb.get_background(pars2)
res2 = data2.angular_diameter_distance(1.7)
drag2 = data2.get_derived_params()['rdrag']
self.assertAlmostEqual(res1, data.angular_diameter_distance(0.7))
self.assertAlmostEqual(res2, data2.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'])
self.assertEqual(pars2.InitPower.ns, data2.Params.InitPower.ns)
data2.calc_background(pars)
self.assertEqual(pars.InitPower.ns, data2.Params.InitPower.ns)
self.assertAlmostEqual(res1, data2.angular_diameter_distance(0.7))
data3 = camb.get_results(pars2)
cl3 = data3.get_lensed_scalar_cls(1000)
self.assertAlmostEqual(res2, data3.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag2, data3.get_derived_params()['rdrag'], places=3)
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'], places=3)
pars.set_for_lmax(3000, lens_potential_accuracy=1)
camb.get_results(pars)
del data3
data4 = camb.get_results(pars2)
cl4 = data4.get_lensed_scalar_cls(1000)
self.assertTrue(np.allclose(cl4, cl3))
def testInstances(self):
pars = camb.set_params(H0=69.1, ombh2=0.032, omch2=0.122, As=3e-9, ns=0.91, omk=0.013,
redshifts=[0.], kmax=0.5)
data = camb.get_background(pars)
res1 = data.angular_diameter_distance(0.7)
drag1 = data.get_derived_params()['rdrag']
pars2 = camb.set_params(H0=65, ombh2=0.022, omch2=0.122, As=3e-9, ns=0.91)
data2 = camb.get_background(pars2)
res2 = data2.angular_diameter_distance(1.7)
drag2 = data2.get_derived_params()['rdrag']
self.assertAlmostEqual(res1, data.angular_diameter_distance(0.7))
self.assertAlmostEqual(res2, data2.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'])
self.assertEqual(pars2.InitPower.ns, data2.Params.InitPower.ns)
data2.calc_background(pars)
self.assertEqual(pars.InitPower.ns, data2.Params.InitPower.ns)
self.assertAlmostEqual(res1, data2.angular_diameter_distance(0.7))
data3 = camb.get_results(pars2)
cl3 = data3.get_lensed_scalar_cls(1000)
self.assertAlmostEqual(res2, data3.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag2, data3.get_derived_params()['rdrag'], places=3)
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'], places=3)
pars.set_for_lmax(3000, lens_potential_accuracy=1)
camb.get_results(pars)
del data3
data4 = camb.get_results(pars2)
cl4 = data4.get_lensed_scalar_cls(1000)
self.assertTrue(np.allclose(cl4, cl3))
def test_quintessence(self):
n = 3
# set zc and fde_zc
pars = camb.set_params(ombh2=0.022, omch2=0.122, thetastar=0.01044341764253,
dark_energy_model='EarlyQuintessence',
m=8e-53, f=0.05, n=n, theta_i=3.1, use_zc=True, zc=1e4, fde_zc=0.1)
camb.get_background(pars)
results = camb.get_results(pars)
self.assertAlmostEqual(results.get_derived_params()['thetastar'], 1.044341764253, delta=1e-5)
def __init__(self, params=None, smica_path=None): # Setting cosmo params if params is None: params = def_cosmo.copy() else: for key, val in def_cosmo.iteritems(): params.setdefault(key,val) self.params = params.copy() #Let's initialize CAMB for distances, growth factor ders, and CMB TT spectrum self.pars = camb.CAMBparams() self.pars.set_cosmology(H0=self.params['H0'], ombh2=self.params['ombh2'], omch2=self.params['omch2'], mnu=self.params['mnu'], omk=self.params['omk'], tau=self.params['tau']) self.pars.InitPower.set_params(As=params['As'], ns=params['ns'], r=0) self.pars.set_for_lmax(2500, lens_potential_accuracy=0); results = camb.get_results(self.pars) self.bkd = camb.get_background(self.pars) self.eta_star = self.bkd.conformal_time(1089) # conformal time at recombination cmb = results.get_cmb_power_spectra(self.pars,lmax=1000, raw_cl=True) self.TCMBmuK = 2.726e6 self.cltt = np.copy(cmb['lensed_scalar'][:,0])*self.TCMBmuK**2 # muK^2 self.zmin = 0 self.zmax = 8 self.nz = 300 self.z = np.linspace(self.zmin,self.zmax,self.nz) ev = results.get_redshift_evolution(1e-2, self.z, ['growth']) self.growth_eta = UnivariateSpline(self.bkd.conformal_time(self.z[::-1]), ev[:, 0][::-1], ext=3) self.der_growtg_eta = self.growth_eta.derivative() if smica_path is None: self.smica_path = '/Users/fbianchini/Research/pSZ/data/smica_nside512.fits' self.smica_init = False
def GetBackgroundFuncs(samples):
ixs = samples.randomSingleSamples_indices()[::40]
DMs = np.zeros((len(ixs), len(redshifts)))
Hs = np.zeros(DMs.shape)
rsDV = np.zeros(DMs.shape)
camb.set_z_outputs(redshifts)
for i, ix in enumerate(ixs):
print(i, ix)
dic = samples.getParamSampleDict(ix)
pars = get_camb_params(dic)
results = camb.get_background(pars)
bao = results.get_background_outputs()
rsDV[i, :] = 1 / bao[:, 0]
DMs[i, :] = bao[:, 2] * (1 + reds)
Hs[i, :] = bao[:, 1]
Hmeans = np.zeros(len(redshifts))
Herrs = np.zeros(len(redshifts))
DMmeans = np.zeros(len(redshifts))
DMerrs = np.zeros(len(redshifts))
for i, z in enumerate(redshifts):
Hmeans[i] = np.mean(Hs[:, i]) / (1 + z)
Herrs[i] = np.std(Hs[:, i]) / (1 + z)
DMmeans[i] = np.mean(DMs[:, i])
DMerrs[i] = np.std(DMs[:, i])
Hinterp = UnivariateSpline([0] + redshifts, [samples.mean('H0')] + list(Hmeans), s=0)
DMinterp = UnivariateSpline([0] + redshifts, [0] + list(DMmeans), s=0)
Herrinterp = UnivariateSpline([0] + redshifts, [samples.std('H0')] + list(Herrs), s=0)
DMerrinterp = UnivariateSpline([0] + redshifts, [0] + list(DMerrs), s=0)
return Hinterp, Herrinterp, DMinterp, DMerrinterp, rsDV
def _init_cosmology(self,params,halofit):
try:
theta = params['theta100']/100.
H0 = None
print("WARNING: Using theta100 parameterization. H0 ignored.")
except:
H0 = params['H0']
theta = None
try:
omm = params['omm']
h = params['H0']/100.
params['omch2'] = omm*h**2-params['ombh2']
print("WARNING: omm specified. Ignoring omch2.")
except:
pass
self.pars = camb.set_params(ns=params['ns'],As=params['As'],H0=H0,
cosmomc_theta=theta,ombh2=params['ombh2'],
omch2=params['omch2'], mnu=params['mnu'],
tau=params['tau'],nnu=params['nnu'],
num_massive_neutrinos=
params['num_massive_neutrinos'],
w=params['w0'],wa=params['wa'],
dark_energy_model='ppf',
halofit_version=self.p['default_halofit'] if halofit is None else halofit,
AccuracyBoost=2)
self.results = camb.get_background(self.pars)
self.params = params
self.h = self.params['H0']/100.
omh2 = self.params['omch2']+self.params['ombh2'] # FIXME: neutrinos
self.om0 = omh2 / (self.params['H0']/100.)**2.
try: self.as8 = self.params['as8']
except: self.as8 = 1
def __init__(self,omega_m,sigma_8,h,z):
self.omega_m = omega_m
self.sigma_8 = sigma_8
self.h = h
self.z = z
self.k_max = 10.0
self.c = 2.99792e+5
#=========================
cosmo = camb.CAMBparams()
cosmo.set_cosmology(H0=100.0*self.h, ombh2=0.048*(self.h**2.0), omch2=(self.omega_m - 0.048)*(self.h**2.0), mnu=0.06, omk=0, tau=0.06)
cosmo.InitPower.set_params(As=2.0e-9, ns=0.973)
results = camb.get_results(cosmo)
cosmo.set_matter_power(redshifts=[0.0], kmax=10.0)
cambres= camb.get_transfer_functions(cosmo)
cosmo.NonLinear = model.NonLinear_both
kh, z, pk = cambres.get_matter_power_spectrum(minkh=1e-3, maxkh=1.0, npoints = 10)
sigma_8_temp = cambres.get_sigma8()
As_new = ((self.sigma_8/sigma_8_temp)**2.0)*(2.0e-9)
cosmo.InitPower.set_params(As=As_new, ns=0.973)
cambres = camb.get_results(cosmo)
backres = camb.get_background(cosmo)
self.chi = backres.comoving_radial_distance(self.z)
self.PK = camb.get_matter_power_interpolator(cosmo, nonlinear=True,
hubble_units=False, k_hunit=False, kmax=self.k_max, zmin = 0.0, zmax=self.z[-1])
self.H_z = (backres.hubble_parameter(self.z))/self.c #Hubble parameter in 1/Mpc
def GetBackgroundFuncs(samples):
ixs = samples.randomSingleSamples_indices()[::40]
DMs = np.zeros((len(ixs), len(redshifts)))
Hs = np.zeros(DMs.shape)
rsDV = np.zeros(DMs.shape)
camb.set_z_outputs(redshifts)
for i, ix in enumerate(ixs):
print(i, ix)
dic = samples.getParamSampleDict(ix)
pars = get_camb_params(dic)
results = camb.get_background(pars)
bao = results.get_background_outputs()
rsDV[i, :] = 1 / bao[:, 0]
DMs[i, :] = bao[:, 2] * (1 + reds)
Hs[i, :] = bao[:, 1]
Hmeans = np.zeros(len(redshifts))
Herrs = np.zeros(len(redshifts))
DMmeans = np.zeros(len(redshifts))
DMerrs = np.zeros(len(redshifts))
for i, z in enumerate(redshifts):
Hmeans[i] = np.mean(Hs[:, i]) / (1 + z)
Herrs[i] = np.std(Hs[:, i]) / (1 + z)
DMmeans[i] = np.mean(DMs[:, i])
DMerrs[i] = np.std(DMs[:, i])
Hinterp = UnivariateSpline([0] + redshifts,
[samples.mean('H0')] + list(Hmeans),
s=0)
DMinterp = UnivariateSpline([0] + redshifts, [0] + list(DMmeans), s=0)
Herrinterp = UnivariateSpline([0] + redshifts,
[samples.std('H0')] + list(Herrs),
s=0)
DMerrinterp = UnivariateSpline([0] + redshifts, [0] + list(DMerrs), s=0)
return Hinterp, Herrinterp, DMinterp, DMerrinterp, rsDV
def get_camb_theory(self, pars):
kmax = 15 * acc
results = camb.get_background(pars)
k_per_logint = None
if self.use_Weyl:
PKWeyl = camb.get_matter_power_interpolator(
pars,
nonlinear=True,
hubble_units=False,
k_hunit=False,
kmax=kmax,
k_per_logint=k_per_logint,
var1=model.Transfer_Weyl,
var2=model.Transfer_Weyl,
zmax=self.zmax,
extrap_kmax=500 * acc)
else:
PKWeyl = None
PKdelta = camb.get_matter_power_interpolator(pars,
nonlinear=True,
hubble_units=False,
k_hunit=False,
kmax=kmax,
k_per_logint=k_per_logint,
zmax=self.zmax,
extrap_kmax=500 * acc)
return results, PKdelta, PKWeyl
def nonlin_ps(z, l_max):
pars_nl = model.CAMBparams(NonLinear = 1, WantTransfer = True, H0=h * 100, omch2=omch2, ombh2=ombh2, YHe = YHe)
pars_nl.DarkEnergy.set_params(w=-1.13)
pars_nl.set_for_lmax(lmax = l_max)
pars_nl.InitPower.set_params(ns=ns, As = 2.196e-09)
results = camb.get_background(pars_nl)
k = np.linspace(- 5, k_max(z, l_max), 1000)
return get_matter_power_interpolator(pars_nl, nonlinear=True, kmax = k_max(z, l_max), k_hunit = True, hubble_units = True)
def r_drag_camb(omega_m,H_0,wb = 0.0225):
pars = camb.CAMBparams()
h = (H_0/100)
pars.set_cosmology(H0=H_0, ombh2=wb, omch2=omega_m*h**2-wb)
results = camb.get_background(pars)
rd = results.get_derived_params()['rdrag']
#print('Derived parameter dictionary: %s'%results.get_derived_params()['rdrag'])
return rd
def __init__(self, redshift=0.0, omega_m=0.3121, omega_b=0.0491, hubble=0.6751, omega_k=0.0, tau=0.063, As=2.130e-9, ns=0.9653,
neutrino_hierarchy='degenerate', num_massive_neutrinos=1, mnu=0.06, nnu=3.046, w=-1.0, sound_speed=1.0, dark_energy_model='fluid', sigma8=None, r_s=None, r_s_type='CAMB',
degree=13, sigma=1, weight=0.5, verbose=False):
import camb
self.verbose = verbose
self.redshift = redshift
self.omega_m = omega_m
self.omega_b = omega_b
self.hubble = hubble
self.ns = ns
self.sigma8 = sigma8
self.degree = degree
self.sigma = sigma
self.weight = weight
if (self.verbose):
print "Using CAMB to generate matter power spectrum"
params = camb.set_params(omch2=(omega_m-omega_b)*hubble**2, ombh2=omega_b*hubble**2, H0=100.0*hubble, omk=omega_k, tau=tau, As=As, ns=ns,
neutrino_hierarchy=neutrino_hierarchy, num_massive_neutrinos=num_massive_neutrinos, mnu=mnu, nnu=nnu,
w=w, sound_speed=sound_speed, dark_energy_model=dark_energy_model)
params.set_matter_power(redshifts=[redshift],kmax=100,accurate_massive_neutrino_transfers=True)
results = camb.get_results(params)
self.k, z, self.pk = results.get_matter_power_spectrum(minkh=1e-4, maxkh=100, npoints = 2000)
self.pk = self.pk[0]
# Normalise the input power spectrum to the current value of sigma8 if one has been passed
if (self.sigma8 is None):
self.sigma8 = results.get_sigma8()[0]
else:
pknorm = norm_pk(self.k, self.pk, self.sigma8)
self.pk *= pknorm
if (r_s is None):
if (r_s_type == 'EH98'):
self.r_s = self.EH98_rs()
if (self.verbose):
print "Setting sound horizon using EH98 formulae: r_s = ", self.r_s
print "Note: This is only used for BAOExtractor model"
elif (r_s_type == 'CAMB'):
self.r_s = camb.get_background(params).get_derived_params()['rdrag']
if (self.verbose):
print "Setting sound horizon using CAMB value: r_s = ", self.r_s
print "Note: This is only used for BAOExtractor model"
else:
print "r_s_type not supported (", r_s_type, "), must be either 'EH98' or 'CAMB', or you must pass in a value for r_s"
exit()
else:
self.r_s = r_s
if (self.verbose):
print "Setting sound horizon using user-defined value: r_s = ", self.r_s
print "Note: This is only used for BAOExtractor model"
self.set_pksmooth()
def get_interpolated():
#For calculating large-scale structure and lensing results yourself, get a power spectrum
#interpolation object. In this example we calculate the CMB lensing potential power
#spectrum using the Limber approximation, using PK=camb.get_matter_power_interpolator() function.
#calling PK(z, k) will then get power spectrum at any k and redshift z in range.
nz = 100 #number of steps to use for the radial/redshift integration
kmax=10 #kmax to use
#First set up parameters as usual
pars = camb.CAMBparams()
#pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122)
#pars.InitPower.set_params(ns=0.965)
pars.set_cosmology(H0=100*para5[i, 3], ombh2=para5[i, 1], omch2=para5[i, 0] - para5[i, 1], mnu=0.0, omk=0, tau=0.0)
#pars.set_dark_energy(w=-1.0, sound_speed=1.0, dark_energy_model='fluid')
# pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=para5[i, 4], r=0)
# pars.set_for_lmax(lmax, lens_potential_accuracy=0);
#For Limber result, want integration over \chi (comoving radial distance), from 0 to chi_*.
#so get background results to find chistar, set up arrage in chi, and calculate corresponding redshifts
results= camb.get_background(pars)
chistar = results.conformal_time(0)- model.tau_maxvis.value
chis = np.linspace(0,chistar,nz)
zs=results.redshift_at_comoving_radial_distance(chis)
#Calculate array of delta_chi, and drop first and last points where things go singular
dchis = (chis[2:]-chis[:-2])/2
chis = chis[1:-1]
zs = zs[1:-1]
#Get the matter power spectrum interpolation object (based on RectBivariateSpline)
#Here for lensing we want the power spectrum of the Weyl potential.
#PK = camb.get_matter_power_interpolator(pars, nonlinear=True,hubble_units=False, k_hunit=False, kmax=kmax,var1=model.Transfer_Weyl,var2=model.Transfer_Weyl, zmax=zs[-1])
PK = camb.get_matter_power_interpolator(pars, nonlinear=True, hubble_units=False, k_hunit=False, kmax=kmax, zmax = zs[-1])
sigma8_camb = results.get_sigma8() # present value of sigma_8 --- check kman, mikh etc
#---------------------------------------------------
sigma8_input = para5[i, 2]
r = (sigma8_input ** 2) / (sigma8_camb ** 2) # rescale factor
#Have a look at interpolated power spectrum results for a range of redshifts
#Expect linear potentials to decay a bit when Lambda becomes important, and change from non-linear growth
plt.figure(figsize=(8,5))
#k=np.exp(np.log(10)*np.linspace(-4,5,1000))
k = kPk[:,0]
#zplot = [0, 0.5, 1, 4 ,20]
zplot = [0.0]
def __init__(self, H0=67.8, ombh2=0.022, omch2=0.122):
#First set up parameters as usual
pars = camb.CAMBparams()
pars.set_cosmology(H0=H0, ombh2=ombh2, omch2=omch2)
pars.InitPower.set_params(ns=0.965)
results = camb.get_background(pars)
self.pars = pars
self.results = results
def __init__(self,sim_path="/gpfs01/astro/workarea/msyriac/data/sims/battaglia/"):
import camb
self.root = sim_path
H0 = 72.0
om = 0.25
ob = 0.04
mnu = 0.
ns = 0.96
As = 2.e-9
h = old_div(H0,100.)
ombh2 = ob*h**2.
omh2 = om*h**2.
omch2 = omh2-ombh2
self.h = h
# cosmology for distances
pars = camb.CAMBparams()
pars.set_cosmology(H0=H0, ombh2=ombh2, omch2=omch2, mnu=mnu)
pars.InitPower.set_params(ns=ns,As=As)
self.results= camb.get_background(pars)
# Snap to Z
alist = np.loadtxt(self.root + 'outputSel.txt')
zlist = np.array((old_div(1.,alist))-1.)
snaplist = np.arange(55,55-len(zlist),-1)
self.snapToZ = lambda s: zlist[snaplist==s][0]
self.allSnaps = list(range(54,34,-1))
# True masses : THIS NEEDS DEBUGGING
self.NumClust= 300
self.trueM500 = {}
self.trueR500 = {}
for snapNum in self.allSnaps:
snap = str(snapNum)
f1 = self.root+'cluster_image_info/CLUSTER_MAP_INFO2PBC.L165.256.FBN2_'+snap+'500.d'
with open(f1, 'rb') as fd:
temp = np.fromfile(file=fd, dtype=np.float32)
data = np.reshape(temp,(self.NumClust,4))
self.trueM500[snap] = data[:,2]*1.e10 /h # Msun #/h
self.trueR500[snap] = data[:,3]*(1.+self.snapToZ(snapNum))/1.e3 #/ self.cc.h # physical Kpc/h -> comoving Mpc R500
# File names
self.files = {}
self.files['star'] = lambda massIndex, snap: self.root + "GEN_Cluster_MassStar_"+str(massIndex)+"L165.256.FBN2_snap"+str(snap)+"_comovFINE.d"
self.files['dm'] = lambda massIndex, snap: self.root + "GEN_Cluster_MassDM_"+str(massIndex)+"L165.256.FBN2_snap"+str(snap)+"_comovFINE.d"
self.files['gas'] = lambda massIndex, snap: self.root + "GEN_Cluster_MassGas_"+str(massIndex)+"L165.256.FBN2_snap"+str(snap)+"_comovFINE.d"
self.files['y'] = lambda massIndex, snap: self.root + "GEN_Cluster_"+str(massIndex)+"L165.256.FBN2_snap"+str(snap)+"_comovFINE.d"
self.files['ksz'] = lambda massIndex, snap: self.root + "GEN_Cluster_kSZ_"+str(massIndex)+"L165.256.FBN2_snap"+str(snap)+"_comovFINE.d"
self.files['kszN'] = lambda massIndex, snap: self.root + "GEN_Cluster_kSZ_"+str(massIndex)+"L165.256.FBN2_snap"+str(snap)+"MAT2.d"
self.PIX = 2048
def getPKinterp(nz=100, kmax=10, myVar=model.Transfer_tot):
"""
example code from http://camb.readthedocs.io/en/latest/CAMBdemo.html
(modified to have nz,kmax,myVar as inputs)
Purpose:
For calculating large-scale structure and lensing results yourself, get a power spectrum
interpolation object. In this example we calculate the CMB lensing potential power
spectrum using the Limber approximation, using PK=camb.get_matter_power_interpolator() function.
calling PK(z, k) will then get power spectrum at any k and redshift z in range.
Inputs:
nz: number of steps to use for the radial/redshift integration
kmax: kmax to use
myVar: the variable to get autopower spectrum of
default: model.Transfer_tot for delta_tot
Returns:
the PK(z,k) interpolator
chistar
chis (array of chi values)
dchis (delta chi array)
zs (redshift array)
pars (CAMB parameters)
"""
#First set up parameters as usual
#pars = camb.CAMBparams()
#pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122)
#pars.InitPower.set_params(ns=0.965)
pars = getPars()
#For Limber result, want integration over \chi (comoving radial distance), from 0 to chi_*.
#so get background results to find chistar, set up arrage in chi, and calculate corresponding redshifts
results = camb.get_background(pars)
chistar = results.conformal_time(0) - model.tau_maxvis.value
chis = np.linspace(0, chistar, nz)
zs = results.redshift_at_comoving_radial_distance(chis)
#Calculate array of delta_chi, and drop first and last points where things go singular
dchis = (chis[2:] - chis[:-2]) / 2
chis = chis[1:-1]
zs = zs[1:-1]
#Get the matter power spectrum interpolation object (based on RectBivariateSpline).
#Here for lensing we want the power spectrum of the Weyl potential.
PK = camb.get_matter_power_interpolator(pars,
nonlinear=True,
hubble_units=False,
k_hunit=False,
kmax=kmax,
var1=myVar,
var2=myVar,
zmax=zs[-1])
return PK, chistar, chis, dchis, zs, pars
def lin_ps(z, l_max):
pars = model.CAMBparams(NonLinear=0,
WantTransfer=True,
H0=h * 100,
omch2=omch2,
ombh2=ombh2,
YHe=YHe)
pars.DarkEnergy.set_params(w=-1.13)
pars.set_for_lmax(lmax=l_max)
pars.InitPower.set_params(ns=ns, As=2.196e-09)
results = camb.get_background(pars)
PK = get_matter_power_interpolator(pars,
nonlinear=False,
kmax=k_max(z, l_max),
k_hunit=True,
hubble_units=True)
return PK.P(z, k)
def nonlin_ps(z, l_max):
pars_nl = model.CAMBparams(NonLinear=1,
WantTransfer=True,
H0=67.3,
omch2=0.1199,
ombh2=0.02205,
YHe=0.24770)
pars_nl.DarkEnergy.set_params(w=-1.13)
pars_nl.set_for_lmax(lmax=l_max)
pars_nl.InitPower.set_params(ns=0.9603, As=2.196e-09)
results = camb.get_background(pars_nl)
k = 10**np.linspace(-6, k_lim(z, l_max), 1000)
return get_matter_power_interpolator(pars_nl,
nonlinear=True,
kmax=k_max(z, l_max),
k_hunit=True,
hubble_units=True)
def cps(z):
pars = model.CAMBparams(NonLinear=1,
WantTransfer=True,
H0=67.3,
omch2=0.1199,
ombh2=0.02205,
YHe=0.24770)
pars.DarkEnergy.set_params(w=-1.13)
#pars.set_for_lmax(lmax = l_max)
pars.InitPower.set_params(ns=0.9603, As=2.196e-09)
results = camb.get_background(pars)
PK = get_matter_power_interpolator(pars,
nonlinear=True,
kmax=10,
k_hunit=True,
hubble_units=True)
PK.P(z, k)
return PK.P(z, k)
def testSymbolic(self):
if fast:
return
import camb.symbolic as s
monopole_source, ISW, doppler, quadrupole_source = s.get_scalar_temperature_sources()
temp_source = monopole_source + ISW + doppler + quadrupole_source
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95, omk=0.1)
data = camb.get_background(pars)
tau = np.linspace(1, 1200, 300)
ks = [0.001, 0.05, 1]
monopole2 = s.make_frame_invariant(s.newtonian_gauge(monopole_source), 'Newtonian')
Delta_c_N = s.make_frame_invariant(s.Delta_c, 'Newtonian')
Delta_c_N2 = s.make_frame_invariant(s.synchronous_gauge(Delta_c_N), 'CDM')
ev = data.get_time_evolution(ks, tau, ['delta_photon', s.Delta_g, Delta_c_N, Delta_c_N2,
monopole_source, monopole2,
temp_source, 'T_source'])
self.assertTrue(np.allclose(ev[:, :, 0], ev[:, :, 1]))
self.assertTrue(np.allclose(ev[:, :, 2], ev[:, :, 3]))
self.assertTrue(np.allclose(ev[:, :, 4], ev[:, :, 5]))
self.assertTrue(np.allclose(ev[:, :, 6], ev[:, :, 7]))
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95)
pars.set_accuracy(lSampleBoost=2)
try:
pars.set_custom_scalar_sources([monopole_source + ISW + doppler + quadrupole_source,
s.scalar_E_source], source_names=['T2', 'E2'],
source_ell_scales={'E2': 2})
data = camb.get_results(pars)
dic = data.get_cmb_unlensed_scalar_array_dict(CMB_unit='muK')
self.assertTrue(np.all(np.abs(dic['T2xT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(dic['TxT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
# default interpolation errors much worse for E
self.assertTrue(np.all(np.abs(dic['E2xE2'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
self.assertTrue(np.all(np.abs(dic['E2xE'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
dic1 = data.get_cmb_power_spectra(CMB_unit='muK')
self.assertTrue(np.allclose(dic1['unlensed_scalar'][2:2000, 1], dic['ExE'][2:2000]))
finally:
pars.set_accuracy(lSampleBoost=1)
s.internal_consistency_checks()
def testSymbolic(self):
if fast: return
import camb.symbolic as s
monopole_source, ISW, doppler, quadrupole_source = s.get_scalar_temperature_sources()
temp_source = monopole_source + ISW + doppler + quadrupole_source
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95, omk=0.1)
data = camb.get_background(pars)
tau = np.linspace(1, 1200, 300)
ks = [0.001, 0.05, 1]
monopole2 = s.make_frame_invariant(s.newtonian_gauge(monopole_source), 'Newtonian')
Delta_c_N = s.make_frame_invariant(s.Delta_c, 'Newtonian')
Delta_c_N2 = s.make_frame_invariant(s.synchronous_gauge(Delta_c_N), 'CDM')
ev = data.get_time_evolution(ks, tau, ['delta_photon', s.Delta_g, Delta_c_N, Delta_c_N2,
monopole_source, monopole2,
temp_source, 'T_source'])
self.assertTrue(np.allclose(ev[:, :, 0], ev[:, :, 1]))
self.assertTrue(np.allclose(ev[:, :, 2], ev[:, :, 3]))
self.assertTrue(np.allclose(ev[:, :, 4], ev[:, :, 5]))
self.assertTrue(np.allclose(ev[:, :, 6], ev[:, :, 7]))
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95)
pars.set_accuracy(lSampleBoost=2)
try:
pars.set_custom_scalar_sources([monopole_source + ISW + doppler + quadrupole_source,
s.scalar_E_source], source_names=['T2', 'E2'],
source_ell_scales={'E2': 2})
data = camb.get_results(pars)
dic = data.get_cmb_unlensed_scalar_array_dict(CMB_unit='muK')
self.assertTrue(np.all(np.abs(dic['T2xT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(dic['TxT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
# default interpolation errors much worse for E
self.assertTrue(np.all(np.abs(dic['E2xE2'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
self.assertTrue(np.all(np.abs(dic['E2xE'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
dic1 = data.get_cmb_power_spectra(CMB_unit='muK')
self.assertTrue(np.allclose(dic1['unlensed_scalar'][2:2000, 1], dic['ExE'][2:2000]))
finally:
pars.set_accuracy(lSampleBoost=1)
s.internal_consistency_checks()
def get_interpolated():
#For calculating large-scale structure and lensing results yourself, get a power spectrum
#interpolation object. In this example we calculate the CMB lensing potential power
#spectrum using the Limber approximation, using PK=camb.get_matter_power_interpolator() function.
#calling PK(z, k) will then get power spectrum at any k and redshift z in range.
nz = 100 #number of steps to use for the radial/redshift integration
kmax=10 #kmax to use
#First set up parameters as usual
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122)
pars.InitPower.set_params(ns=0.965)
#For Limber result, want integration over \chi (comoving radial distance), from 0 to chi_*.
#so get background results to find chistar, set up arrage in chi, and calculate corresponding redshifts
results= camb.get_background(pars)
chistar = results.conformal_time(0)- model.tau_maxvis.value
chis = np.linspace(0,chistar,nz)
zs=results.redshift_at_comoving_radial_distance(chis)
#Calculate array of delta_chi, and drop first and last points where things go singular
dchis = (chis[2:]-chis[:-2])/2
chis = chis[1:-1]
zs = zs[1:-1]
#Get the matter power spectrum interpolation object (based on RectBivariateSpline)
#Here for lensing we want the power spectrum of the Weyl potential.
#PK = camb.get_matter_power_interpolator(pars, nonlinear=True,hubble_units=False, k_hunit=False, kmax=kmax,var1=model.Transfer_Weyl,var2=model.Transfer_Weyl, zmax=zs[-1])
PK = camb.get_matter_power_interpolator(pars, nonlinear=True, hubble_units=False, k_hunit=False, kmax=kmax)
#Have a look at interpolated power spectrum results for a range of redshifts
#Expect linear potentials to decay a bit when Lambda becomes important, and change from non-linear growth
plt.figure(figsize=(8,5))
k=np.exp(np.log(10)*np.linspace(-4,5,1000))
zplot = [0, 0.5, 1, 4 ,20]
for z in zplot:
ax0.loglog(k, PK.P(z,k))
#plt.xlim([1e-4,kmax])
#plt.xlabel('k Mpc')
#plt.ylabel('$P_\Psi\, Mpc^{-3}$')
plt.legend(['z=%s'%z for z in zplot]);
def get_camb_theory(self, pars):
kmax = 15 * acc
results = camb.get_background(pars)
k_per_logint = None
if self.use_Weyl:
PKWeyl = camb.get_matter_power_interpolator(pars, nonlinear=True,
hubble_units=False, k_hunit=False, kmax=kmax,
k_per_logint=k_per_logint,
var1=model.Transfer_Weyl, var2=model.Transfer_Weyl,
zmax=self.zmax,
extrap_kmax=500 * acc)
else:
PKWeyl = None
PKdelta = camb.get_matter_power_interpolator(pars, nonlinear=True,
hubble_units=False, k_hunit=False, kmax=kmax,
k_per_logint=k_per_logint,
zmax=self.zmax, extrap_kmax=500 * acc)
return results, PKdelta, PKWeyl
def get_g_camb(self):
import camb
dw_dz = lambda z: 1 / (self.a0 * self.H0 * self.E(z))
z_vis = np.linspace(0, 20, 5000)
pars = camb.set_params(H0=100 * self.h,
ombh2=self.Omega_Bh2,
omch2=self.Omega0 * self.h**2 - self.Omega_Bh2,
ns=self.n,
tau=self.tau)
data = camb.get_background(pars)
back_ev = data.get_background_redshift_evolution(z_vis,
['x_e', 'visibility'],
format='array')
g_interpolation = glueAsymptode(
interpolate(z_vis, back_ev[:, 1]),
min=0.1,
minAsym=lambda z: interpolate(z_vis, back_ev[:, 1])(0.1) *
(1 + z)**2)
norm = self.__num.integrate(lambda z: g_interpolation(z) * dw_dz(z),
min(z_vis), max(z_vis))
g_func = lambda z: (1 - np.exp(-self.tau)) / norm * g_interpolation(z)
return g_func
#import matplotlib.colors as mcolors from scipy.integrate import quad,simps,romberg from scipy.special import spherical_jn, gamma #import rotation as ro #import lensing as le import numba import camb from IPython import embed arcmin2rad = np.pi / 180. / 60. rad2arcmin = 1./arcmin2rad #Camb initialisation pars= camb.CAMBparams() data= camb.get_background(pars) #SI constants Omega_b = 0.0486 p_cr0 = 8.62E-27 chi = (1-0.24)/(1-0.12) mu_e = 1.14 m_p = 1.6726E-27 sig_t = 6.65246E-29 omega_lamb = 0.6911 omega_k = 0. omega_r = 9.2364E-5 omega_m = 0.3089 #H_0 = 2.195E-18 #H_0 is in km/s/Mpc H_0 = 67.74
def testBackground(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, omch2=0.122, YHe=0.2453, mnu=0.07, omk=0)
zre = camb.get_zre_from_tau(pars, 0.06)
age = camb.get_age(pars)
self.assertAlmostEqual(zre, 8.39, 2)
self.assertAlmostEqual(age, 13.65, 2)
data = camb.CAMBdata()
bao = data.get_BAO([0.57, 0.27], pars)
data = camb.CAMBdata()
data.calc_background(pars)
DA = data.angular_diameter_distance(0.57)
H = data.hubble_parameter(0.27)
self.assertAlmostEqual(DA, bao[0][2], 3)
self.assertAlmostEqual(H, bao[1][1], 3)
age2 = data.physical_time(0)
self.assertAlmostEqual(age, age2, 4)
data.comoving_radial_distance(0.48)
t0 = data.conformal_time(0)
self.assertAlmostEqual(t0, data.tau0)
t1 = data.conformal_time(11.5)
t2 = data.comoving_radial_distance(11.5)
self.assertAlmostEqual(t2, t0 - t1, 2)
self.assertAlmostEqual(t1, 4200.78, 2)
chistar = data.conformal_time(0) - data.tau_maxvis
chis = np.linspace(0, chistar, 197)
zs = data.redshift_at_comoving_radial_distance(chis)
chitest = data.comoving_radial_distance(zs)
self.assertTrue(np.sum((chitest - chis) ** 2) < 1e-3)
theta = data.cosmomc_theta()
self.assertAlmostEqual(theta, 0.0104759965, 5)
derived = data.get_derived_params()
self.assertAlmostEqual(derived['age'], age, 2)
self.assertAlmostEqual(derived['rdrag'], 146.976, 2)
self.assertAlmostEqual(derived['rstar'], data.sound_horizon(derived['zstar']), 2)
# Test BBN consistency, base_plikHM_TT_lowTEB best fit model
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.YHe, 0.245347, 5)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.010408566, 7)
self.assertAlmostEqual(data.get_derived_params()['kd'], 0.14055, 4)
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0,
bbn_predictor=bbn.BBN_table_interpolator())
self.assertAlmostEqual(pars.YHe, 0.2453469, 5)
self.assertAlmostEqual(pars.get_Y_p(), bbn.BBN_table_interpolator().Y_p(0.022242, 0), 5)
# test massive sterile models as in Planck papers
pars.set_cosmology(H0=68.0, ombh2=0.022305, omch2=0.11873, mnu=0.06, nnu=3.073, omk=0, meffsterile=0.013)
self.assertAlmostEqual(pars.omnuh2, 0.00078, 5)
self.assertAlmostEqual(pars.YHe, 0.24573, 5)
self.assertAlmostEqual(pars.N_eff, 3.073, 4)
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.773, 2)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104103, 6)
# test dark energy
pars.set_cosmology(H0=68.26, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars.set_dark_energy(w=-1.0226, dark_energy_model='fluid')
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.789, 2)
scal = data.luminosity_distance(1.4)
vec = data.luminosity_distance([1.2, 1.4, 0.1, 1.9])
self.assertAlmostEqual(scal, vec[1], 5)
pars.set_dark_energy() # re-set defaults
# test theta
pars.set_cosmology(cosmomc_theta=0.0104085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.H0, 67.5512, 2)
with self.assertRaises(CAMBParamRangeError):
pars.set_cosmology(cosmomc_theta=0.0204085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95)
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122, omk=-0.05)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
self.assertAlmostEqual(pars.H0, 49.7148, places=3)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95, wa=0,
dark_energy_model='ppf')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95,
dark_energy_model='DarkEnergyFluid', initial_power_model='InitialPowerLaw')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
with self.assertRaises(CAMBValueError):
camb.set_params(dark_energy_model='InitialPowerLaw')
data.calc_background(pars)
h2 = (data.Params.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('baryon'), data.Params.ombh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('nu'), data.Params.omnuh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
pars.set_cosmology(H0=67, mnu=1, neutrino_hierarchy='normal')
data.calc_background(pars)
h2 = (pars.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
redshifts = np.array([0.005, 0.01, 0.3, 0.9342, 4, 27, 321.5, 932, 1049, 1092, 2580, 1e4, 2.1e7])
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_dark_energy(w=-1.8)
data.calc_background(pars)
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_cosmology(cosmomc_theta=0.0104085)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104085)
derived = data.get_derived_params()
pars.Accuracy.BackgroundTimeStepBoost = 2
data.calc_background(pars)
derived2 = data.get_derived_params()
self.assertAlmostEqual(derived['thetastar'], derived2['thetastar'], places=5)
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.11, neutrino_hierarchy='inverted')
self.assertEqual(pars.num_nu_massive, 3)
self.assertEqual(pars.nu_mass_numbers[1], 1)
self.assertEqual(pars.nu_mass_eigenstates, 2)
self.assertAlmostEqual(pars.nu_mass_fractions[0], 0.915197, places=4)
import sys, platform, os
from matplotlib import pyplot as plt
import numpy as np
import camb
from camb import model, initialpower
import h5py, os
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122)
cambdata = camb.get_background(pars)
h5f = h5py.File(os.environ['PCAT_DATA_PATH'] + '/data/inpt/adis.h5', 'w')
redssour = np.linspace(0., 5., 100)
redshost = np.linspace(0., 5., 100)
adis = cambdata.angular_diameter_distance(redssour)
adistdim = np.zeros((100, 100))
for k, z0 in enumerate(redssour):
for l, z1 in enumerate(redshost):
adistdim[k, l] = cambdata.angular_diameter_distance2(z0, z1)
h5f.create_dataset('reds', data=redssour)
h5f.create_dataset('adis', data=adis)
h5f.create_dataset('adistdim', data=adistdim)
h5f.close()
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.06, omk=0, tau=0.06)
pars.InitPower.set_params(ns=0.965, r=0)
pars.set_for_lmax(2500, lens_potential_accuracy=0);
path = '/Users/tansu/Desktop/infl/'
os.system('mkdir -p %s' % path)
def testBackground(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5,
ombh2=0.022,
omch2=0.122,
YHe=0.2453,
mnu=0.07,
omk=0)
zre = camb.get_zre_from_tau(pars, 0.06)
age = camb.get_age(pars)
self.assertAlmostEqual(zre, 8.39, 2)
self.assertAlmostEqual(age, 13.65, 2)
data = camb.CAMBdata()
bao = data.get_BAO([0.57, 0.27], pars)
data = camb.CAMBdata()
data.calc_background(pars)
DA = data.angular_diameter_distance(0.57)
H = data.hubble_parameter(0.27)
self.assertAlmostEqual(DA, bao[0][2], 3)
self.assertAlmostEqual(H, bao[1][1], 3)
age2 = data.physical_time(0)
self.assertAlmostEqual(age, age2, 4)
data.comoving_radial_distance(0.48)
t0 = data.conformal_time(0)
t1 = data.conformal_time(11.5)
t2 = data.comoving_radial_distance(11.5)
self.assertAlmostEqual(t2, t0 - t1, 2)
self.assertAlmostEqual(t1, 4200.78, 2)
chistar = data.conformal_time(0) - model.tau_maxvis.value
chis = np.linspace(0, chistar, 197)
zs = data.redshift_at_comoving_radial_distance(chis)
chitest = data.comoving_radial_distance(zs)
self.assertTrue(np.sum((chitest - chis)**2) < 1e-3)
theta = data.cosmomc_theta()
self.assertAlmostEqual(theta, 0.0104759965, 5)
derived = data.get_derived_params()
self.assertAlmostEqual(derived['age'], age, 2)
self.assertAlmostEqual(derived['rdrag'], 146.976, 2)
# Test BBN consistency, base_plikHM_TT_lowTEB best fit model
pars.set_cosmology(H0=67.31,
ombh2=0.022242,
omch2=0.11977,
mnu=0.06,
omk=0)
self.assertAlmostEqual(pars.YHe, 0.245336, 5)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.01040862, 7)
self.assertAlmostEqual(data.get_derived_params()['kd'], 0.14055, 4)
pars.set_cosmology(H0=67.31,
ombh2=0.022242,
omch2=0.11977,
mnu=0.06,
omk=0,
bbn_predictor=bbn.BBN_table_interpolator())
self.assertAlmostEqual(pars.YHe, 0.2453469, 5)
self.assertAlmostEqual(pars.get_Y_p(),
bbn.BBN_table_interpolator().Y_p(0.022242, 0),
5)
# test massive sterile models as in Planck papers
pars.set_cosmology(H0=68.0,
ombh2=0.022305,
omch2=0.11873,
mnu=0.06,
nnu=3.073,
omk=0,
meffsterile=0.013)
self.assertAlmostEqual(pars.omegan * (pars.H0 / 100)**2, 0.00078, 5)
self.assertAlmostEqual(pars.YHe, 0.24573, 5)
self.assertAlmostEqual(pars.N_eff(), 3.073, 4)
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.773, 2)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104103, 6)
# test dark energy
pars.set_cosmology(H0=68.26,
ombh2=0.022271,
omch2=0.11914,
mnu=0.06,
omk=0)
pars.set_dark_energy(w=-1.0226, dark_energy_model='fluid')
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.789, 2)
scal = data.luminosity_distance(1.4)
vec = data.luminosity_distance([1.2, 1.4, 0.1, 1.9])
self.assertAlmostEqual(scal, vec[1], 5)
pars.set_dark_energy() # re-set defaults
# test theta
pars.set_cosmology(cosmomc_theta=0.0104085,
H0=None,
ombh2=0.022271,
omch2=0.11914,
mnu=0.06,
omk=0)
self.assertAlmostEqual(pars.H0, 67.5512, 2)
with self.assertRaises(CAMBParamRangeError):
pars.set_cosmology(cosmomc_theta=0.0204085,
H0=None,
ombh2=0.022271,
omch2=0.11914,
mnu=0.06,
omk=0)
pars = camb.set_params(cosmomc_theta=0.0104077,
H0=None,
ombh2=0.022,
omch2=0.122,
w=-0.95)
self.assertAlmostEqual(
camb.get_background(pars, no_thermo=True).cosmomc_theta(),
0.0104077, 7)
pars.set_dark_energy()
def testBackground(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, omch2=0.122, YHe=0.2453, mnu=0.07, omk=0)
zre = camb.get_zre_from_tau(pars, 0.06)
age = camb.get_age(pars)
self.assertAlmostEqual(zre, 8.39, 2)
self.assertAlmostEqual(age, 13.65, 2)
data = camb.CAMBdata()
bao = data.get_BAO([0.57, 0.27], pars)
data = camb.CAMBdata()
data.calc_background(pars)
DA = data.angular_diameter_distance(0.57)
H = data.hubble_parameter(0.27)
self.assertAlmostEqual(DA, bao[0][2], 3)
self.assertAlmostEqual(H, bao[1][1], 3)
age2 = data.physical_time(0)
self.assertAlmostEqual(age, age2, 4)
data.comoving_radial_distance(0.48)
t0 = data.conformal_time(0)
self.assertAlmostEqual(t0, data.tau0)
t1 = data.conformal_time(11.5)
t2 = data.comoving_radial_distance(11.5)
self.assertAlmostEqual(t2, t0 - t1, 2)
self.assertAlmostEqual(t1, 4200.78, 2)
chistar = data.conformal_time(0) - data.tau_maxvis
chis = np.linspace(0, chistar, 197)
zs = data.redshift_at_comoving_radial_distance(chis)
chitest = data.comoving_radial_distance(zs)
self.assertTrue(np.sum((chitest - chis) ** 2) < 1e-3)
theta = data.cosmomc_theta()
self.assertAlmostEqual(theta, 0.0104759965, 5)
derived = data.get_derived_params()
self.assertAlmostEqual(derived['age'], age, 2)
self.assertAlmostEqual(derived['rdrag'], 146.976, 2)
self.assertAlmostEqual(derived['rstar'], data.sound_horizon(derived['zstar']), 2)
# Test BBN consistency, base_plikHM_TT_lowTEB best fit model
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.YHe, 0.245347, 5)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.010408566, 7)
self.assertAlmostEqual(data.get_derived_params()['kd'], 0.14055, 4)
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0,
bbn_predictor=bbn.BBN_table_interpolator())
self.assertAlmostEqual(pars.YHe, 0.2453469, 5)
self.assertAlmostEqual(pars.get_Y_p(), bbn.BBN_table_interpolator().Y_p(0.022242, 0), 5)
# test massive sterile models as in Planck papers
pars.set_cosmology(H0=68.0, ombh2=0.022305, omch2=0.11873, mnu=0.06, nnu=3.073, omk=0, meffsterile=0.013)
self.assertAlmostEqual(pars.omnuh2, 0.00078, 5)
self.assertAlmostEqual(pars.YHe, 0.24573, 5)
self.assertAlmostEqual(pars.N_eff, 3.073, 4)
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.773, 2)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104103, 6)
# test dark energy
pars.set_cosmology(H0=68.26, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars.set_dark_energy(w=-1.0226, dark_energy_model='fluid')
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.789, 2)
scal = data.luminosity_distance(1.4)
vec = data.luminosity_distance([1.2, 1.4, 0.1, 1.9])
self.assertAlmostEqual(scal, vec[1], 5)
pars.set_dark_energy() # re-set defaults
# test theta
pars.set_cosmology(cosmomc_theta=0.0104085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.H0, 67.5512, 2)
with self.assertRaises(CAMBParamRangeError):
pars.set_cosmology(cosmomc_theta=0.0204085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95)
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122, omk=-0.05)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
self.assertAlmostEqual(pars.H0, 49.7148, places=3)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95, wa=0,
dark_energy_model='ppf')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95,
dark_energy_model='DarkEnergyFluid', initial_power_model='InitialPowerLaw')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
with self.assertRaises(CAMBValueError):
camb.set_params(dark_energy_model='InitialPowerLaw')
data.calc_background(pars)
h2 = (data.Params.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('baryon'), data.Params.ombh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('nu'), data.Params.omnuh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
pars.set_cosmology(H0=67, mnu=1, neutrino_hierarchy='normal')
data.calc_background(pars)
h2 = (pars.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
redshifts = np.array([0.005, 0.01, 0.3, 0.9342, 4, 27, 321.5, 932, 1049, 1092, 2580, 1e4, 2.1e7])
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_dark_energy(w=-1.8)
data.calc_background(pars)
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_cosmology(cosmomc_theta=0.0104085)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104085)
derived = data.get_derived_params()
pars.Accuracy.BackgroundTimeStepBoost = 2
data.calc_background(pars)
derived2 = data.get_derived_params()
self.assertAlmostEqual(derived['thetastar'], derived2['thetastar'], places=5)
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.11, neutrino_hierarchy='inverted')
self.assertEqual(pars.num_nu_massive, 3)
self.assertEqual(pars.nu_mass_numbers[1], 1)
self.assertEqual(pars.nu_mass_eigenstates, 2)
self.assertAlmostEqual(pars.nu_mass_fractions[0], 0.915197, places=4)
def testAssigments(self):
ini = os.path.join(os.path.dirname(__file__), '..', 'inifiles', 'planck_2018.ini')
if os.path.exists(ini):
pars = camb.read_ini(ini)
self.assertTrue(np.abs(camb.get_background(pars).cosmomc_theta() * 100 / 1.040909 - 1) < 2e-5)
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, mnu=0, omch2=0.1)
self.assertAlmostEqual(pars.omegam, (0.022 + 0.1) / 0.685 ** 2)
with self.assertRaises(AttributeError):
# noinspection PyPropertyAccess
pars.omegam = 1
pars.InitPower.set_params(ns=0.01)
data = camb.CAMBdata()
data.Params = pars
self.assertEqual(data.Params.InitPower.ns, pars.InitPower.ns)
d = dark_energy.DarkEnergyFluid(w=-0.95)
pars.DarkEnergy = d
self.assertEqual(pars.DarkEnergy.w, -0.95)
pars.DarkEnergy = dark_energy.AxionEffectiveFluid(w_n=0.4)
data.Params = pars
self.assertEqual(pars.DarkEnergy.w_n, 0.4)
pars.z_outputs = [0.1, 0.4]
self.assertEqual(pars.z_outputs[1], 0.4)
pars.z_outputs[0] = 0.3
self.assertEqual(pars.z_outputs[0], 0.3)
pars.z_outputs = pars.z_outputs
pars.z_outputs = []
pars.z_outputs = None
self.assertFalse(len(pars.z_outputs))
with self.assertRaises(TypeError):
pars.DarkEnergy = initialpower.InitialPowerLaw()
pars.NonLinear = model.NonLinear_both
printstr = str(pars)
self.assertTrue('Want_CMB_lensing = True' in printstr and
"NonLinear = NonLinear_both" in printstr)
pars.NonLinear = model.NonLinear_lens
self.assertTrue(pars.NonLinear == model.NonLinear_lens)
with self.assertRaises(ValueError):
pars.NonLinear = 4
pars.nu_mass_degeneracies = np.zeros(3)
self.assertTrue(len(pars.nu_mass_degeneracies) == 3)
pars.nu_mass_degeneracies = [1, 2, 3]
self.assertTrue(pars.nu_mass_degeneracies[1] == 2)
pars.nu_mass_degeneracies[1] = 5
self.assertTrue(pars.nu_mass_degeneracies[1] == 5)
with self.assertRaises(CAMBParamRangeError):
pars.nu_mass_degeneracies = np.zeros(7)
pars.nu_mass_eigenstates = 0
self.assertFalse(len((pars.nu_mass_degeneracies[:1])))
pars = camb.set_params(**{'InitPower.ns': 1.2, 'WantTransfer': True})
self.assertEqual(pars.InitPower.ns, 1.2)
self.assertTrue(pars.WantTransfer)
pars.DarkEnergy = None
from camb.sources import GaussianSourceWindow
pars = camb.CAMBparams()
pars.SourceWindows = [GaussianSourceWindow(), GaussianSourceWindow(redshift=1)]
self.assertEqual(pars.SourceWindows[1].redshift, 1)
pars.SourceWindows[0].redshift = 2
self.assertEqual(pars.SourceWindows[0].redshift, 2)
self.assertTrue(len(pars.SourceWindows) == 2)
pars.SourceWindows[0] = GaussianSourceWindow(redshift=3)
self.assertEqual(pars.SourceWindows[0].redshift, 3)
self.assertTrue('redshift = 3.0' in str(pars))
pars.SourceWindows = pars.SourceWindows[0:1]
self.assertTrue(len(pars.SourceWindows) == 1)
pars.SourceWindows = []
self.assertTrue(len(pars.SourceWindows) == 0)
for name in like.names:
common.append(name in JLA.names or 'SDSS' + name in JLA.names
or 'sn' + name in JLA.names)
common = np.array(common, dtype=np.bool)
print(like.nsn, np.sum(common), like.nsn - np.sum(common))
redshifts = np.logspace(-2, 1, 1000)
samples = g.sampleAnalyser.samplesForRoot(
'base_plikHM_TTTEEE_lowl_lowE_lensing')
ixs = samples.randomSingleSamples_indices()
dists = np.zeros((len(ixs), len(redshifts)))
sndists = np.zeros((len(ixs), like.nsn))
for i, ix in enumerate(ixs):
dic = samples.getParamSampleDict(ix)
camb_pars = get_camb_params(dic)
results = camb.get_background(camb_pars)
dists[i, :] = 5 * np.log10(
(1 + redshifts)**2 * results.angular_diameter_distance(redshifts))
sndists[i, :] = 5 * np.log10(
(1 + like.zcmb)**2 * results.angular_diameter_distance(like.zcmb))
paramdic = g.bestfit('base_plikHM_TTTEEE_lowl_lowE_lensing').getParamDict()
camb_pars = get_camb_params(paramdic)
results = camb.get_background(camb_pars)
invvars = 1.0 / like.pre_vars
wtval = np.sum(invvars)
offset = 5 * np.log10(1e-5)
lumdists = 5 * np.log10(
(1 + like.zcmb) *
def get_background(self, z=0.0):
self.backresults = camb.get_background(self.pars)
## self.chistar = self.backresults.conformal_time(0) - model.tau_maxvis.value
self.zstar = self.backresults.get_derived_params()['zstar']
import pickle
import rotation as ro
import lensing as le
import numba
import camb
from IPython import embed
#embed()
arcmin2rad = np.pi / 180. / 60.
rad2arcmin = 1. / arcmin2rad
#Camb initialisation
pars = camb.CAMBparams()
data_camb = camb.get_background(pars)
cosmo = Cosmo()
cmbspec = cosmo.cmb_spectra(7000)
#cmbspec_r = Cosmo({'r':0.1}).cmb_spectra(12000,spec='tensor')[:,2]
clbb_r = Cosmo({'r': 1.}).cmb_spectra(400, spec='tensor')[:, 2]
MC_lin = pickle.load(open("MAGCAMB_ONLY_linear.pkl", "rb"))
MC_log = pickle.load(open("MAGCAMB_ONLY_log.pkl", "rb"))
FR = pickle.load(open("FINAL_FR.pkl", "rb"))
FR_lin = FR['mydic']
FR_log = FR['mydic1']
#Set up a new set of parameters for CAMB
pars = camb.CAMBparams()
#This function sets up CosmoMC-like settings, with one massive neutrino and helium set using BBN consistency
def TestAgainstCAMB(results_dir):
""" Function to compare our implementation to CAMB for the comoving angular
diameter distance, Hubble rate, and ionization fraction, as well as the
redshift of baryon drag, and sound horizon at baryon drag.
"""
# Parameters from PL18
p = Params(omega_b=0.02212,
omega_c=0.1206,
H0=66.88,
Nnu_massive=1.0,
Nnu_massless=2.046,
mnu=0.06 * eV,
Omega_k=0.,
Tcmb=2.7255,
w=-1,
Gamma_P=0.24,
F=1.14,
fDM=0.)
# Redshift range of interest for recombination
z = np.linspace(500, 2500, 1000)
# Compute recfast
zarr, Xe_H, Xe_He, Xe, TM = recfast.Xe_frac(p.Gamma_P,
p.Tcmb,
p.Omega_c,
p.Omega_b,
p.Omega_lambda,
p.Omega_k,
np.sqrt(p.hsquared),
p.Nnu_massless + p.Nnu_massive,
p.F,
p.fDM,
switch=1)
xe = interp1d(zarr, Xe, kind='cubic')
# Comopute ionization history from CAMB (also uses RECFAST)
camb_res = camb.get_background(
camb.set_params(H0=p.H0,
ombh2=p.omega_b,
omch2=p.omega_c,
mnu=p.mnu,
nnu=p.Nnu_massive + p.Nnu_massless,
tau=0.07,
YHe=p.Gamma_P,
recombination_model='Recfast'))
back_ev = camb_res.get_background_redshift_evolution(z, ['x_e'],
format='array')
# 1. Plot comparison of ionization histories
fig, ax = plt.subplots(1, 1)
ax.plot(z, xe(z), label=r"${\rm Ours}$")
ax.plot(z, back_ev[:, 0], label=r"${\rm CAMB}$")
ax.legend(loc=4, frameon=False)
ax.tick_params(axis='both', direction='inout')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.set_ylabel(r"${\rm Ionization~Fraction,}~X_{\rm e}$")
ax.set_xlabel(r"${\rm Redshift,}~z$")
fig.savefig(results_dir / "CompareXeCAMB.pdf")
# 2. Plot comparison of comoving angular diameter distance
z = np.linspace(0, 4, 100)
DA = camb_res.angular_diameter_distance(z)
ourda = np.vectorize(lambda x: angular_diameter_distance(x, p))
fig, ax = plt.subplots(1, 1)
ax.plot(z, DA, label=r"${\rm CAMB}$")
ax.plot(z, ourda(z) / Mpc / (1 + z), '--', label=r"${\rm Ours}$")
ax.legend(loc=2, frameon=False)
ax.set_ylabel(
r"${\rm Comoving~Angular~Diameter~Distance,}~D_A(z)~({\rm Mpc})$")
ax.set_xlabel(r"${\rm Redshift,}~z$")
ax.tick_params(axis='both', direction='inout')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
fig.savefig(results_dir / "CompareDACAMB.pdf")
# 3. Plot comparison of Hubble rate
z = np.linspace(0, 4, 100)
CAMB_H = camb_res.hubble_parameter(z)
ourH = np.vectorize(lambda x: H(x, p))
fig, ax = plt.subplots(1, 1)
ax.plot(z, CAMB_H, label=r"${\rm CAMB}$")
ax.plot(z, ourH(z) / km * second * Mpc, '--', label=r"${\rm Ours}$")
ax.legend(loc=2, frameon=False)
ax.set_ylabel(r"${\rm Hubble~Rate,}~H(z)~({\rm km/s/Mpc})$")
ax.set_xlabel(r"${\rm Redshift,}~z$")
ax.tick_params(axis='both', direction='inout')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
fig.savefig(results_dir / "CompareHCAMB.pdf")
# Compare derived parameters
CAMB_params = camb_res.get_derived_params()
print("Dark Energy")
print("-----------------------")
print("CAMB: ", camb_res.get_Omega('de'))
print("Ours: ", p.Omega_lambda)
print("Redshift of baryon drag")
print("-----------------------")
print("CAMB: ", CAMB_params['zdrag'])
print("Ours: ", z_drag(p))
print("Sound Horizon at Baryon Drag")
print("----------------------------")
print("CAMB :", camb_res.sound_horizon(CAMB_params['zdrag']))
print("Ours :", r_drag(p) / Mpc)
return
common = []
for name in like.names:
common.append(name in JLA.names or 'SDSS' + name in JLA.names or 'sn' + name in JLA.names)
common = np.array(common, dtype=np.bool)
print(like.nsn, np.sum(common), like.nsn - np.sum(common))
redshifts = np.logspace(-2, 1, 1000)
samples = g.sampleAnalyser.samplesForRoot('base_plikHM_TTTEEE_lowl_lowE_lensing')
ixs = samples.randomSingleSamples_indices()
dists = np.zeros((len(ixs), len(redshifts)))
sndists = np.zeros((len(ixs), like.nsn))
for i, ix in enumerate(ixs):
dic = samples.getParamSampleDict(ix)
camb_pars = get_camb_params(dic)
results = camb.get_background(camb_pars)
dists[i, :] = 5 * np.log10((1 + redshifts) ** 2 * results.angular_diameter_distance(redshifts))
sndists[i, :] = 5 * np.log10((1 + like.zcmb) ** 2 * results.angular_diameter_distance(like.zcmb))
paramdic = g.bestfit('base_plikHM_TTTEEE_lowl_lowE_lensing').getParamDict()
camb_pars = get_camb_params(paramdic)
results = camb.get_background(camb_pars)
invvars = 1.0 / like.pre_vars
wtval = np.sum(invvars)
offset = 5 * np.log10(1e-5)
lumdists = 5 * np.log10((1 + like.zcmb) ** 2 * results.angular_diameter_distance(like.zcmb))
redshifts = np.logspace(-2, 1, 1000)
d = results.angular_diameter_distance(redshifts)
def Cl_kk(theta, acc_npts):
global chis
global zs
global dzs
global pars
global K_k
global om_tot
global w_DE
global w1
global kmax
global PK_kk
H0, ombh2, omch2, ns, As, mnu, w_DE, tau, wa = theta
#Set up a new set of parameters for CAMB
pars = camb.CAMBparams()
#This function sets up CosmoMC-like settings, with one massive neutrino and helium set using BBN consistency
pars.set_accuracy(AccuracyBoost=3.0, lSampleBoost=3.0, lAccuracyBoost=3.0)
pars.set_cosmology(H0=H0, cosmomc_theta = None, ombh2=ombh2, omch2=omch2, mnu=mnu, omk=0, tau=tau, nnu=3.046, standard_neutrino_neff=3.046, num_massive_neutrinos = 1, neutrino_hierarchy='degenerate')
pars.InitPower.set_params(ns=ns, r=0, As=As)
pars.set_for_lmax(3000, lens_potential_accuracy=3, max_eta_k=30*3000)
pars.set_dark_energy(w=w_DE,wa=wa,dark_energy_model='ppf')
#calculate results for these parameters
results = camb.get_results(pars)
om_tot = ( ombh2+omch2+mnu/94.07*(3.046/3.0)**0.75 )/((pars.H0/100)**2)
nz = acc_npts #number of steps to use for the radial/redshift integration
kmax=10 #kmax to use
# #First set up parameters as usual
# pars = camb.CAMBparams()
# pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122)
# pars.InitPower.set_params(ns=0.965)
#For Limber result, want integration over \chi (comoving radial distance), from 0 to chi_*.
#so get background results to find chistar, set up arrage in chi, and calculate corresponding redshifts
results= camb.get_background(pars)
chistar = results.conformal_time(0)- results.tau_maxvis
chis = np.linspace(0,chistar,nz)
zs=results.redshift_at_comoving_radial_distance(chis)
#Calculate array of delta_chi, and drop first and last points where things go singular
dchis = (chis[2:]-chis[:-2])/2
dzs = (zs[2:]-zs[:-2])/2
chis = chis[1:-1]
zs = zs[1:-1]
#Get the matter power spectrum interpolation object (based on RectBivariateSpline).
#Here for lensing we want the power spectrum of the Weyl potential.
PK_kk = camb.get_matter_power_interpolator(pars, nonlinear=False,
hubble_units=False, k_hunit=False, kmax=kmax, var1=model.Transfer_tot, var2=model.Transfer_tot,
zmax=zs[-1])
ls = np.arange(2,2001+1, dtype=np.float64)
w1 = np.ones(chis.shape)
const = 3*om_tot*(pars.H0**2)/2/(pars.H0*np.sqrt(om_tot*(1+zs)**3 + 4.2*(10**(-5))/((pars.H0/100.)**2)*(1+zs)**4 + (1-om_tot)*(1+zs)**(3*(1+w_DE)) ))/(2.99792*(10**5))
win = ((chistar-chis)/(chistar))
K_k = const*(1+zs)*win*chis
pool = Pool(processes = 32)
cl_kk = []
cl_kk = pool.map(getCl, ls)
pool.close()
pool.join()
pars.set_dark_energy()
return cl_kk
}
l_plot_low_limit = 10
l_plot_upp_limit = 600
redshift = 2
l_max = 600
pars = model.CAMBparams(NonLinear=0,
WantTransfer=True,
H0=67.3,
omch2=0.1199,
ombh2=0.02205,
YHe=0.24770)
pars.DarkEnergy.set_params(w=-1.13)
pars.set_for_lmax(lmax=l_max)
pars.InitPower.set_params(ns=0.9603, As=2.196e-09)
results = camb.get_background(pars)
k = 10**np.linspace(-6, 1, 1000)
PK = get_matter_power_interpolator(pars,
nonlinear=False,
kmax=1,
k_hunit=True,
hubble_units=True)
pars_nl = model.CAMBparams(NonLinear=1,
WantTransfer=True,
H0=67.3,
omch2=0.1199,
ombh2=0.02205,
YHe=0.24770)
pars_nl.DarkEnergy.set_params(w=-1.13)
pars_nl.set_for_lmax(lmax=l_max)
def testAssigments(self):
ini = os.path.join(os.path.dirname(__file__), '..', 'inifiles', 'planck_2018.ini')
if os.path.exists(ini):
pars = camb.read_ini(ini)
self.assertTrue(np.abs(camb.get_background(pars).cosmomc_theta() * 100 / 1.040909 - 1) < 2e-5)
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, mnu=0, omch2=0.1)
self.assertAlmostEqual(pars.omegam, (0.022 + 0.1) / 0.685 ** 2)
with self.assertRaises(AttributeError):
pars.omegam = 1
pars.InitPower.set_params(ns=0.01)
data = camb.CAMBdata()
data.Params = pars
self.assertEqual(data.Params.InitPower.ns, pars.InitPower.ns)
d = dark_energy.DarkEnergyFluid(w=-0.95)
pars.DarkEnergy = d
self.assertEqual(pars.DarkEnergy.w, -0.95)
pars.DarkEnergy = dark_energy.AxionEffectiveFluid(w_n=0.4)
data.Params = pars
self.assertEqual(pars.DarkEnergy.w_n, 0.4)
pars.z_outputs = [0.1, 0.4]
self.assertEqual(pars.z_outputs[1], 0.4)
pars.z_outputs[0] = 0.3
self.assertEqual(pars.z_outputs[0], 0.3)
pars.z_outputs = pars.z_outputs
pars.z_outputs = []
pars.z_outputs = None
self.assertFalse(len(pars.z_outputs))
with self.assertRaises(TypeError):
pars.DarkEnergy = initialpower.InitialPowerLaw()
pars.NonLinear = model.NonLinear_both
printstr = str(pars)
self.assertTrue('Want_CMB_lensing = True' in printstr and
"NonLinear = NonLinear_both" in printstr)
pars.NonLinear = model.NonLinear_lens
self.assertTrue(pars.NonLinear == model.NonLinear_lens)
with self.assertRaises(ValueError):
pars.NonLinear = 4
pars.nu_mass_degeneracies = np.zeros(3)
self.assertTrue(len(pars.nu_mass_degeneracies) == 3)
pars.nu_mass_degeneracies = [1, 2, 3]
self.assertTrue(pars.nu_mass_degeneracies[1] == 2)
pars.nu_mass_degeneracies[1] = 5
self.assertTrue(pars.nu_mass_degeneracies[1] == 5)
with self.assertRaises(CAMBParamRangeError):
pars.nu_mass_degeneracies = np.zeros(7)
pars.nu_mass_eigenstates = 0
self.assertFalse(len((pars.nu_mass_degeneracies[:1])))
pars = camb.set_params(**{'InitPower.ns': 1.2, 'WantTransfer': True})
self.assertEqual(pars.InitPower.ns, 1.2)
self.assertTrue(pars.WantTransfer)
pars.DarkEnergy = None
from camb.sources import GaussianSourceWindow
pars = camb.CAMBparams()
pars.SourceWindows = [GaussianSourceWindow(), GaussianSourceWindow(redshift=1)]
self.assertEqual(pars.SourceWindows[1].redshift, 1)
pars.SourceWindows[0].redshift = 2
self.assertEqual(pars.SourceWindows[0].redshift, 2)
self.assertTrue(len(pars.SourceWindows) == 2)
pars.SourceWindows[0] = GaussianSourceWindow(redshift=3)
self.assertEqual(pars.SourceWindows[0].redshift, 3)
self.assertTrue('redshift = 3.0' in str(pars))
pars.SourceWindows = pars.SourceWindows[0:1]
self.assertTrue(len(pars.SourceWindows) == 1)
pars.SourceWindows = []
self.assertTrue(len(pars.SourceWindows) == 0)
