def cosmo_setup(self):
""" This method runs CAMB with the cosmology specified
by the configuration file `self.camb_ini_path`. From
this run we take the primordial tensor BB spectrum and
the lensing BB spectrum as templates for the likelihood
BB model.
"""
saved_output_path = self.camb_ini_path.with_suffix('.h5')
if saved_output_path.exists():
with h5py.File(saved_output_path.as_posix(), 'r') as f:
if ('tensor' in f.keys()) and ('lensed_scalar' in f.keys()):
self._Cl_BB_prim = f['tensor'][:self.lmax + 1, 2]
self._Cl_BB_lens = f['lensed_scalar'][:self.lmax + 1, 2]
else:
pars = camb.read_ini(self.camb_ini_path.as_posix())
pars.InitPower.set_params(r=1)
pars.WantTensors = True
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(CMB_unit='muK', raw_cl=True)
with h5py.File(saved_output_path.as_posix(), 'a') as f:
for key, value in powers.items():
dset = f.require_dataset(key,
dtype=value.dtype,
shape=value.shape)
dset[...] = value
self._Cl_BB_prim = np.array(powers['tensor'][:self.lmax + 1, 2])
self._Cl_BB_lens = np.array(powers['lensed_scalar'][:self.lmax + 1,
2])
def generate_spectra_from_camb_ini(self, camb_ini_file_name):
"""
Generates a new spectra from a CAMB ini file
"""
camb_ini_file_path = os.path.join(self.global_paths['camb_params_dir'],
camb_ini_file_name)
params = camb.read_ini(camb_ini_file_path)
results = camb.get_results(params)
powers = results.get_cmb_power_spectra(params, CMB_unit='muK')
self.from_dict_spec(dict_spec=powers)
def main(cmdargs):
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-i',
'--ini',
type=str,
required=True,
help='Input config file for CAMB')
parser.add_argument('-o',
'--out',
type=str,
required=True,
help='Output FITS file')
parser.add_argument(
'--H0',
type=float,
required=False,
default=None,
help='Hubble parameter, if not given use the one from the config file')
parser.add_argument('--fid-Ok',
type=float,
default=None,
required=False,
help='Omega_k(z=0) of fiducial LambdaCDM cosmology')
parser.add_argument(
'--fid-wl',
type=float,
default=None,
required=False,
help='Equation of state of dark energy of fiducial LambdaCDM cosmology'
)
parser.add_argument(
'--z-ref',
type=float,
required=False,
default=None,
help=
'Power-spectrum redshift, if not given use the one from the config file'
)
parser.add_argument(
'--plot',
action='store_true',
required=False,
help='Plot the resulting correlation functions and power-spectra')
args = parser.parse_args(cmdargs)
### Parameters kmin and kmax to get exactly same as DR12
minkh = 1.e-4
maxkh = 1.1525e3
npoints = 814
userprint('INFO: running CAMB on {}'.format(args.ini))
pars = camb.read_ini(os.path.expandvars(args.ini))
pars.Transfer.kmax = maxkh
if not args.z_ref is None:
pars.Transfer.PK_redshifts[0] = args.z_ref
if not args.H0 is None:
pars.H0 = args.H0
if not args.fid_Ok is None:
pars.omk = args.fid_Ok
if not args.fid_wl is None:
pars.DarkEnergy.w = args.fid_wl
results = camb.get_results(pars)
k, z, pk = results.get_matter_power_spectrum(minkh=minkh,
maxkh=pars.Transfer.kmax,
npoints=npoints)
pk = pk[1]
pars = results.Params
pars2 = results.get_derived_params()
### Save the parameters
cat = {}
cat['H0'] = pars.H0
cat['ombh2'] = pars.ombh2
cat['omch2'] = pars.omch2
cat['omnuh2'] = pars.omnuh2
cat['OK'] = pars.omk
cat['OL'] = results.get_Omega('de')
cat['ORPHOTON'] = results.get_Omega('photon')
cat['ORNEUTRI'] = results.get_Omega('neutrino')
cat['OR'] = cat['ORPHOTON'] + cat['ORNEUTRI']
cat['OM'] = (cat['ombh2'] + cat['omch2'] + cat['omnuh2']) / (cat['H0'] /
100.)**2
cat['W'] = pars.DarkEnergy.w
cat['TCMB'] = pars.TCMB
cat['NS'] = pars.InitPower.ns
cat['ZREF'] = pars.Transfer.PK_redshifts[0]
cat['SIGMA8_ZREF'] = results.get_sigma8()[0]
cat['SIGMA8_Z0'] = results.get_sigma8()[1]
cat['F_ZREF'] = results.get_fsigma8()[0] / results.get_sigma8()[0]
cat['F_Z0'] = results.get_fsigma8()[1] / results.get_sigma8()[1]
cat['ZDRAG'] = pars2['zdrag']
cat['RDRAG'] = pars2['rdrag']
c = SPEED_LIGHT / 1000. ## km/s
h = cat['H0'] / 100.
dh = c / (results.hubble_parameter(cat['ZREF']) / h)
dm = (1. + cat['ZREF']) * results.angular_diameter_distance(
cat['ZREF']) * h
cat['DH'] = dh
cat['DM'] = dm
cat['DHoRD'] = cat['DH'] / (cat['RDRAG'] * h)
cat['DMoRD'] = cat['DM'] / (cat['RDRAG'] * h)
### Get the Side-Bands
### Follow 2.2.1 of Kirkby et al. 2013: https://arxiv.org/pdf/1301.3456.pdf
coef_Planck2015 = (cat['H0'] / 67.31) * (cat['RDRAG'] / 147.334271564563)
sb1_rmin = 50. * coef_Planck2015
sb1_rmax = 82. * coef_Planck2015
sb2_rmin = 150. * coef_Planck2015
sb2_rmax = 190. * coef_Planck2015
xi = nbodykit.cosmology.correlation.pk_to_xi(k, pk)
r = np.logspace(-7., 3.5, 10000)
xi = xi(r)
def f_xiSB(r, am3, am2, am1, a0, a1):
par = [am3, am2, am1, a0, a1]
model = np.zeros((len(par), r.size))
tw = r != 0.
model[0, tw] = par[0] / r[tw]**3
model[1, tw] = par[1] / r[tw]**2
model[2, tw] = par[2] / r[tw]**1
model[3, tw] = par[3]
model[4, :] = par[4] * r
model = np.array(model)
return model.sum(axis=0)
w = ((r >= sb1_rmin) & (r < sb1_rmax)) | ((r >= sb2_rmin) & (r < sb2_rmax))
sigma = 0.1 * np.ones(xi.size)
sigma[(r >= sb1_rmin - 2.) & (r < sb1_rmin + 2.)] = 1.e-6
sigma[(r >= sb2_rmax - 2.) & (r < sb2_rmax + 2.)] = 1.e-6
popt, pcov = curve_fit(f_xiSB, r[w], xi[w], sigma=sigma[w])
model = f_xiSB(r, *popt)
xiSB = xi.copy()
ww = (r >= sb1_rmin) & (r < sb2_rmax)
xiSB[ww] = model[ww]
pkSB = nbodykit.cosmology.correlation.xi_to_pk(r, xiSB, extrap=True)
pkSB = pkSB(k)
pkSB *= pk[-1] / pkSB[-1]
out = fitsio.FITS(args.out, 'rw', clobber=True)
head = [{'name': k, 'value': float(v)} for k, v in cat.items()]
out.write([k, pk, pkSB],
names=['K', 'PK', 'PKSB'],
header=head,
extname='PK')
out.close()
if args.plot:
plt.plot(r, xi * r**2, label='Full')
w = (r >= sb1_rmin) & (r < sb1_rmax)
plt.plot(r[w], xi[w] * r[w]**2, label='SB1')
w = (r >= sb2_rmin) & (r < sb2_rmax)
plt.plot(r[w], xi[w] * r[w]**2, label='SB2')
plt.plot(r, xiSB * r**2, label='noBAO')
plt.xlabel(r'$r\,[h^{-1}\,\mathrm{Mpc}]$')
plt.ylabel(r'$r^{2}\,\xi(r)$')
plt.legend()
plt.grid()
plt.show()
plt.plot(k, pk, label='Full')
plt.plot(k, pkSB, label='noBAO')
plt.xscale('log')
plt.yscale('log')
plt.xlabel(r'$k$')
plt.ylabel(r'$P(k)$')
plt.legend()
plt.grid()
plt.show()
plt.plot(k, pk - pkSB, label='BAO')
plt.xscale('log')
plt.xlabel(r'$k$')
plt.ylabel(r'$P(k)$')
plt.legend()
plt.grid()
plt.show()
betaV_squared = float(sys.argv[1])
betaE_squared = float(sys.argv[2])
directory = '/Users/mac/Desktop/CircularPolarisation-project/plots/GFEmodified-spectra' # 'path_of_your_directory'
Want_fig = False # if False no fig. are produced.
twopi = 2.0 * np.pi
fourpi = 4.0 * np.pi
# this correspond to lmax=2000, this value can be change. The max value is 3987.
lmax_v = 1999
lmax_e_b = 1999
tau = 0.05905
pars = camb.read_ini(
'/Users/mac/Documents/Work-University/Codes/camb-puliti/CAMB-0.1.7/params.ini'
)
pars.Reion.Reionization = True
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit='muK')
cl_tilde_R = powers['unlensed_total']
tildedle_R = cl_tilde_R[2:, 1]
tildedlb_R = cl_tilde_R[2:, 2]
tildedlte_R = cl_tilde_R[2:, 3]
pars.Reion.Reionization = False
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit='muK')
cl_tilde = powers['unlensed_total']
CMB_unit='muK')
tt_unlensed = unlensed['TxT']
lensed = results.get_lensed_scalar_cls(lmax=2100, CMB_unit='muK')
transposed = np.transpose(lensed)
tt_lensed = transposed[0]
ee = transposed[1]
te = transposed[3]
fig, ax = plt.subplots()
tt_unlensed = np.delete(tt_unlensed, [0, 1])
tt_lensed = np.delete(tt_lensed, [0, 1])
ax.plot(tt_lensed, linewidth=1, color='red')
ax.plot(tt_unlensed, linewidth=1, color='blue')
ax.set_xlim([None, 2500])
ax.set_ylim([None, 7000])
ax.set(xlabel='Multipole Moment (l)',
ylabel='CMB_Unit (uK)',
title='Cl TT Lensed CMB Power Spectrum')
fig.savefig("Cl_TT_lensed.pdf")
params = camb.read_ini('camb_interface/camb_params.ini')
camb_plot_lensed(params, params.ombh2, params.omch2, params.omnuh2)
# camb_plot_unlensed(params, params.ombh2, params.omch2, params.omnuh2)
plt.show()
print('done')
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)
boo=boo+1
print(chilow,chihigh,np.min(r),np.max(r))
if (boo==0):
return True
else:
return False
def getnearestsnap(alist,zmid):
""" get the closest snapshot """
zsnap = 1/alist[:,1]-1.
return alist[np.argmin(np.abs(zsnap-zmid)),0]
#-------- Running camb to get comoving distances -----------
#Load all parameters from camb file
pars = camb.read_ini('params_Planck15Table4LastColumn.ini')
h = pars.h
pars.set_for_lmax(2000, lens_potential_accuracy=3)
pars.set_matter_power(redshifts=[0.], kmax=200.0)
pars.NonLinearModel.set_params(halofit_version='takahashi')
camb.set_feedback_level(level=100)
results = camb.get_results(pars)
chilow = shellwidth*(shellnum+0)
chiupp = shellwidth*(shellnum+1)
chimid = 0.5*(chilow+chiupp)
ntiles = int(np.ceil(chiupp/boxL))
print("tiling [%dx%dx%d]"%(2*ntiles,2*ntiles,2*ntiles))
zmid = results.redshift_at_comoving_radial_distance(chimid/h)
print('Generating map for halos in the range [%3.f - %.3f Mpc/h]'%(chilow,chiupp))
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)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: Pedro da Silveira Ferreira
"""
import numpy as np
import camb
import time
from camb import model, initialpower
from matplotlib import pyplot as plt
import healpy as hp
lmax = 2505
pars = camb.read_ini('planck_2018_camb_params.dat')
pars.set_for_lmax(lmax)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit='muK')
for name in powers:
print(name)
dl_camb_py = powers['lensed_scalar'][:, 0]
cl_camb_py = (2 * np.pi * dl_camb_py[0:lmax + 1] /
(np.arange(lmax + 1) *
(np.arange(1, lmax + 2)))) / (10**12) # (10**12)->microK^2
cl_camb_py[0] = 0
calplanck = 1.000442**2
dl_planck_dat = np.loadtxt(
'COM_PowerSpect_CMB-base-plikHM-TTTEEE-lowl-lowE-lensing-minimum-theory_R3.01.txt'
)
#from cosmotools import utils #from cosmotools import theory #from cosmotools import cosmo import numpy as np import healpy as hp import camb from camb import model, initialpower import sys h = 0.6777 dir_in = sys.argv[1] dir_out = sys.argv[2] cambpar = sys.argv[3] #'mdpl2_params.ini' pars = camb.read_ini(cambpar) results = camb.get_results(pars) #--------------------------------------------------------------------------- Nsnap = 146 #highest slicenumber-4+1 dchish = 25 chish = (np.arange(Nsnap + 1) + 0.5) * dchish chishuu = (np.arange(Nsnap + 1) + 1.0) * dchish chishll = (np.arange(Nsnap + 1) + 0.0) * dchish chis = chish / h # mid-z in Mpc chisuu = chishuu / h # upper edge chisll = chishll / h # lower edges dchis = dchish / h # tmpchis[1:]-tmpchis[:-1]
from cosmic_kite import cosmic_kite
import matplotlib.pyplot as plt
import camb
import numpy as np
# Let's compute a spectra with CAMB for random cosmologies
pars = camb.read_ini('/home/martin/Descargas/CAMB/inifiles/planck_2018.ini')
H0 = np.random.uniform(61, 74)
omb = np.random.uniform(0.0213, 0.023)
omc = np.random.uniform(0.11, 0.125)
n = np.random.uniform(0.94, 0.985)
tau = np.random.uniform(0.02, 0.092)
As = np.random.uniform(1.95e-9, 2.2e-9)
#calculate results for these parameters
pars.set_cosmology(H0 = H0, ombh2 = omb, omch2 = omc, tau = tau)
pars.set_for_lmax(3000)
pars.InitPower.set_params(As = As, ns = n)
results = camb.get_results(pars)
#get dictionary of CAMB power spectra
powers = results.get_cmb_power_spectra(pars, CMB_unit='muK')
camb_tt = powers['total'][2:2650,0]
camb_ee = powers['total'][2:2650,1]
camb_te = powers['total'][2:2650,3]
l = np.arange(2,2650)
camb_ps = np.concatenate((camb_tt, camb_ee, camb_te))
parser.add_argument(
'--plot',
action='store_true',
required=False,
help='Plot the resulting correlation functions and power-spectra')
args = parser.parse_args()
### Parameters kmin and kmax to get exactly same as DR12
minkh = 1.e-4
maxkh = 1.1525e3
npoints = 814
print('INFO: running CAMB on {}'.format(args.ini))
pars = camb.read_ini(os.path.expandvars(args.ini))
pars.Transfer.kmax = maxkh
if not args.z_ref is None:
pars.Transfer.PK_redshifts[0] = args.z_ref
if not args.H0 is None:
pars.H0 = args.H0
if not args.fid_Ok is None:
pars.omk = args.fid_Ok
if not args.fid_wl is None:
pars.DarkEnergy.w = args.fid_wl
results = camb.get_results(pars)
k, z, pk = results.get_matter_power_spectrum(minkh=minkh,
maxkh=pars.Transfer.kmax,
npoints=npoints)
pk = pk[1]
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
# noinspection PyTypeChecker
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
pars = camb.set_params(**{
'H0': 67,
'ombh2': 0.002,
'r': 0.1,
'Accuracy.AccurateBB': True
})
self.assertEqual(pars.Accuracy.AccurateBB, True)
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)
params = camb.get_valid_numerical_params()
self.assertEqual(
params, {
'ombh2', 'deltazrei', 'omnuh2', 'tau', 'omk', 'zrei',
'thetastar', 'nrunrun', 'meffsterile', 'nnu', 'ntrun',
'HMCode_A_baryon', 'HMCode_eta_baryon', 'HMCode_logT_AGN',
'cosmomc_theta', 'YHe', 'wa', 'cs2', 'H0', 'mnu', 'Alens',
'TCMB', 'ns', 'nrun', 'As', 'nt', 'r', 'w', 'omch2'
})
params2 = camb.get_valid_numerical_params(
dark_energy_model='AxionEffectiveFluid')
self.assertEqual(params2.difference(params),
{'fde_zc', 'w_n', 'zc', 'theta_i'})
import sys, platform, os
from pylab import *
import numpy as np
from scipy.integrate import odeint
from scipy.interpolate import interp1d
#!from LCDMCosmology import *
import scipy.optimize as optimize
camb_path = '/Users/visinelli/Documents/CAMB2016/camb_quint/fortran/'
sys.path.insert(0, camb_path)
import camb
from camb import model, initialpower
print('Using CAMB %s installed at %s' %
(camb.__version__, os.path.dirname(camb.__file__)))
pars = camb.read_ini(
os.path.join(camb_path, 'inifiles', 'inifiles/params_200.ini'))
print(pars)
class QuintCosmology_try(LCDMCosmology):
def __init__(self, varylam=True, varyV0=True, varyA=True, varylB=True):
## two parameters: Om and h
self.varyV0 = varyV0
self.varylam = varylam
self.varyA = varyA
self.varylB = varylB
self.lam = lam_par.value
self.lB = lB_par.value
self.A = A_par.value
self.V0 = V0_par.value
def map_likelihood(base_camb_param_file,
base_info_file,
target_dir,
param_range,
label,
lmin,
lmax,
like_file,
enabled_spectra=['TT', 'TE', 'TB', 'EE', 'EB', 'BB']):
metadata = {}
metadata['model'] = camb.read_ini(base_camb_param_file)
metadata['base_cl_prefix'] = target_dir + 'cls_' + label
metadata['currparam'] = []
metadata['start_clfile'] = None
def execute(curr_metadata):
results = camb.get_results(curr_metadata['model'])
cls = results.get_total_cls(CMB_unit='muK')
ells = np.arange(len(cls)).reshape(len(cls), 1)
cls = np.append(ells, cls, axis=1)
parstring = curr_metadata['currparam'][0] + str(
curr_metadata['currparam'][1])
clfname = curr_metadata['base_cl_prefix'] + '_' + parstring + '.dat'
np.savetxt(clfname, cls)
if curr_metadata['start_clfile'] is None:
curr_metadata['start_clfile'] = clfname
curr_metadata['cl_filelist'].write(
str(curr_metadata['currparam'][1]) + ' ' + clfname.split('/')[-1] +
'\n')
return curr_metadata
def update(curr_metadata, par_name, par_val):
namelist = par_name.split('.')
namelist.reverse()
model = curr_metadata['model']
currobj = model
currname = namelist[-1]
while len(namelist) > 1:
currobj = getattr(currobj, namelist.pop())
currname = namelist[-1]
setattr(currobj, currname, par_val)
curr_metadata['model'] = model
curr_metadata['currparam'] = [currname, par_val]
return curr_metadata
cllist_name = target_dir + 'cllist_' + label + '.dat'
with open(cllist_name, 'w') as cllistfile:
metadata['cl_filelist'] = cllistfile
metadata = param_recursor(param_range, execute, update, metadata)
commlike = '/mn/stornext/u3/eirikgje/src/Commander/commander1/src/comm_process_resfiles/comm_like_tools'
base_info_file = target_dir + base_info_file + '.txt'
curr_info_file = target_dir + 'info_' + label + '.txt'
process_parameter_file(base_info_file,
curr_info_file,
new_parameter_dict={'DATAFILE': like_file})
spectra = ['TT', 'TE', 'TB', 'EE', 'EB', 'BB']
spectrum_flags = [
't' if spec in enabled_spectra else 'f' for spec in spectra
]
run_command([
commlike, 'fast_par_estimation', curr_info_file,
metadata['start_clfile'], cllist_name,
str(lmin),
str(lmax)
] + spectrum_flags + ['.true.', target_dir + label + '_likelihood.dat'])
c3 = fits.Column(name='Z', array=totz, format='D')
c4 = fits.Column(name='DZ', array=totdz, format='E')
c5 = fits.Column(name='VEL_LOS', array=totvlos, format='E')
hdu = fits.BinTableHDU.from_columns([c1, c2, c3, c4, c5])
hdr = fits.Header()
hdr['NGALBOX'] = ngalbox # total number defined as length of ra array
primary_hdu = fits.PrimaryHDU(header=hdr)
hdul = fits.HDUList([primary_hdu, hdu])
hdul.writeto(out_file, overwrite=True)
#-------- Running camb to get comoving distances -----------
#Load all parameters from camb file
pars = camb.read_ini(file_camb)
h = pars.h
pars.set_for_lmax(2000, lens_potential_accuracy=3)
pars.set_matter_power(redshifts=[0.], kmax=200.0)
pars.NonLinearModel.set_params(halofit_version='takahashi')
camb.set_feedback_level(level=100)
results = camb.get_results(pars)
if shellnums is None:
shellnum_min = int(
results.comoving_radial_distance(zmin) * h // shellwidth)
shellnum_max = int(
results.comoving_radial_distance(zmax) * h // shellwidth + 1)
shellnums = list(range(shellnum_min, shellnum_max + 1))
else:
shellnums = list(map(int, shellnums.split(",")))
