def __init__(self, base_folder=None, likelihoods=None):
fullnames = odict([["commander", "commander_v4.1_lm49.clik"],
["camspec", "CAMspec_v6.2TN_2013_02_26_dist.clik"],
["lowlike", "lowlike_v222.clik"]])
likelihoods_fullnames = []
if likelihoods:
for lik in likelihoods:
if lik.lower() in fullnames:
likelihoods_fullnames.append(fullnames[lik.lower()])
else:
raise ValueError("Likelihood name not recognised: %s.\n" %
lik + "Valid ones are " +
str(fullnames.keys()))
self._likelihoods_names = likelihoods_fullnames
else:
self._likelihoods_names = fullnames.values()
# Initialize!
self._likelihoods = odict()
for lik in self._likelihoods_names:
full_path = os.path.join(base_folder, lik)
try:
self._likelihoods[lik] = clik.clik(full_path)
except clik.lkl.CError:
raise ValueError("'clik' failed to initialise the requested " +
"likelihood %s" % lik +
", probably because it was" +
" not found on the given folder: '%s'" %
full_path)
# Get nuisance parameters
self._nuisance_parameters = dict(
[lik_name, {}] for lik_name in self._likelihoods_names)
for lik in self._likelihoods_names:
names = self._likelihoods[lik].extra_parameter_names
self._nuisance_parameters[lik] = ({} if not names else odict(
[[pname, None] for pname in names]))
def main_CMB(argv):
lklfile = argv[1]
lkl = clik.clik(lklfile)
for clfile in argv[2:]:
cls = nm.loadtxt(clfile)
nres = lkl(cls.flat[:])
print(nres)
def __init__(self, base_folder=None, likelihoods=None):
fullnames = odict([["commander", "commander_v4.1_lm49.clik"],
["camspec", "CAMspec_v6.2TN_2013_02_26_dist.clik"],
["lowlike", "lowlike_v222.clik"]])
likelihoods_fullnames = []
if likelihoods:
for lik in likelihoods:
if lik.lower() in fullnames:
likelihoods_fullnames.append(fullnames[lik.lower()])
else:
raise ValueError("Likelihood name not recognised: %s.\n"%lik+
"Valid ones are "+str(fullnames.keys()))
self._likelihoods_names = likelihoods_fullnames
else:
self._likelihoods_names = fullnames.values()
# Initialize!
self._likelihoods = odict()
for lik in self._likelihoods_names:
full_path = os.path.join(base_folder, lik)
try:
self._likelihoods[lik] = clik.clik(full_path)
except clik.lkl.CError:
raise ValueError("'clik' failed to initialise the requested "+
"likelihood %s"%lik+", probably because it was"+
" not found on the given folder: '%s'"%full_path)
# Get nuisance parameters
self._nuisance_parameters = dict([lik_name,{}]
for lik_name in self._likelihoods_names)
for lik in self._likelihoods_names:
names = self._likelihoods[lik].extra_parameter_names
self._nuisance_parameters[lik] = ({} if not names else
odict([[pname,None] for pname in names]))
def initialise(self):
# Importing Planck's clik library (only once!)
try:
clik
except NameError:
if not self.path:
path_to_installation = get_path_to_installation()
if path_to_installation:
self.path_clik = os.path.join(path_to_installation, "code",
common_path)
self.path_data = os.path.join(path_to_installation, "data",
common_path)
else:
self.log.error(
"No path given to the Planck likelihood. Set the "
"likelihood property 'path' or the common property "
"'%s'.", _path_install)
raise HandledException
else:
self.path_clik = self.path
self.log.info("Importing clik from %s", self.path_clik)
# test and import clik
is_installed_clik(self.path_clik,
log_and_fail=True,
import_it=False)
import clik
# Loading the likelihood data
clik_file = os.path.join(self.path_data, self.clik_file)
# for lensing, some routines change. Intializing a flag for easier
# testing of this condition
self.lensing = "lensing" in self.name
try:
self.clik = (clik.clik_lensing(clik_file)
if self.lensing else clik.clik(clik_file))
except clik.lkl.CError:
self.log.error(
"The .clik file was not found where specified in the 'clik_file' field "
"of the settings of this likelihood. Maybe the 'path' given is not "
"correct? The full path where the .clik file was searched for is '%s'",
clik_file)
raise HandledException
self.expected_params = list(self.clik.extra_parameter_names)
# line added to deal with a bug in planck likelihood release:
# A_planck called A_Planck in plik_lite
if "plikHM_lite" in self.name:
i = self.expected_params.index('A_Planck')
self.expected_params[i] = 'A_planck'
self.log.info(
"Corrected nuisance parameter name A_Planck to A_planck")
# Check that the parameters are the right ones
assert set(self.input_params.keys()) == set(self.expected_params), (
"Likelihoods parameters do not coincide with the ones clik understands."
)
# Placeholder for vector passed to clik
self.l_maxs = self.clik.get_lmax()
length = (len(self.l_maxs)
if self.lensing else len(self.clik.get_has_cl()))
self.vector = np.zeros(
np.sum(self.l_maxs) + length + len(self.expected_params))
def __init__(self,
clik_file,
**nuisance):
super(clik,self).__init__(**nuisance)
import clik as _clik
self.clik = _clik.clik(clik_file)
def setup(self):
"""
Sets up the Planck likelihood
"""
self.likes = []
for i, f in enumerate(self.clik_files):
l = clik.clik(f)
self.likes.append(l)
nn = len(l.extra_parameter_names)
if nn != len(self.nu_inds[i]):
raise Warning('Index arrays %i does not have correct shape.'%i)
def do_all_chi2(dffile,bestfit,npar=0):
import clik
from scipy.stats.distributions import chi2
lkl = clik.clik(dffile)
lkl_full = lkl(bffile_from_cosmomc(dffile,bestfit))
lkl_add = get_lkl_coadd(dffile,bestfit,all=True)
n_add = len(lkl_add[1])
lkl_add=lkl_add[-1]
nextra = len(lkl.extra_parameter_names)
oo,Jt0 = ordering_from_smica(dffile)
n_full = len(oo)
print ("full lkl : %g (%g deg) -> %g PTE %g"%(lkl_full,n_full-nextra-npar, -lkl_full*2./(n_full-nextra-npar), chi2.sf(lkl_full*-2,n_full-nextra-npar)))
print ("coadd lkl : %g (%g deg) -> %g PTE %g"%(lkl_add,n_add-nextra-npar, -lkl_add*2./(n_add-nextra-npar), chi2.sf(lkl_add*-2,n_add-nextra-npar)))
def setup(self):
"""
Sets up the Planck likelihood
"""
self.likes = []
for i, f in enumerate(self.clik_files):
l = clik.clik(f)
self.likes.append(l)
nn = len(l.extra_parameter_names)
if nn != len(self.nu_inds[i]):
raise Warning('Index arrays %i does not have correct shape.' %
i)
def main(argv):
pars = clik.miniparse(argv[1])
cl = nm.loadtxt(pars.initdata)
lkl = clik.clik(pars.input_object)
offset = nm.sum(nm.array(lkl.lmax) + 1)
offset += lkl.extra_parameter_names.index(pars.parameter)
ps = nm.linspace(pars.float.beg, pars.float.end, pars.float.step)
res = ps * 0.
for i, v in enumerate(ps):
cl[offset] = v
res[i] = lkl(cl)
res = nm.array([ps, res]).T
res.tofile(pars.res, sep="\n")
def __init__(self,
clik_file,
auto_reject_errors=False,
lensing=None,
**nuisance):
super().__init__(**arguments())
from clik import clik, clik_lensing
if lensing or "lensing" in clik_file:
loaded_cliks[clik_file] = self.clik = loaded_cliks[
clik_file] if clik_file in loaded_cliks else clik_lensing(
clik_file)
self.lensing = True
self.clik_specs = ['pp'] + clik_specs
else:
loaded_cliks[clik_file] = self.clik = loaded_cliks[
clik_file] if clik_file in loaded_cliks else clik(clik_file)
self.lensing = False
self.clik_specs = clik_specs
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2015_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2015_DATA is not set.')
### Planck 2015 lite high ells TT
hell_TTlite = clik.clik(clik_root + '/hi_l/plik_lite/plik_lite_v18_TT.clik')
hell_TTlite_pars = hell_TTlite.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate(
(class_run.lensed_cl()['tt'][:2509] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in hell_TTlite_pars])))
return hell_TTlite(args)
def main_CMB(argv):
clikl = clik.clik(sys.argv[1])
extn = clikl.extra_parameter_names
lkl = hpy.File(sys.argv[1],"r")["clik"]
print("clik lkl file = %s"%sys.argv[1])
print(" number of likelihoods = %d"%lkl.attrs["n_lkl_object"])
print(" lmax ( "+ " ".join([nl+" = %d"%ll for nl,ll in zip(("TT","EE","BB","TE","TB","EB"),lkl.attrs["lmax"]) if ll >-1])+" )")
print(" number of varying extra parameters %d"%(len(extn)))
for n in extn:
print(" %s"%n)
if "prior" in lkl:
names = lkl["prior"].attrs["name"]
names = [names[i*256:(i+1)*256].strip() for i in range(len(names)/256)]
print(" gaussian priors on %s"%", ".join(names))
loc = lkl["prior/loc"][:]
print(" at \n %s"%" ".join([str(l) for l in loc]))
var = lkl["prior/var"][:]
if len(var)==len(loc):
var = nm.diag(var)
var.shape=(len(loc),-1)
print(" with variance")
print("\n".join([" "+" ".join([str(v) for v in vl]) for vl in var]))
if "default" in lkl:
loc = lkl["default/loc"][:]
print(" number of fixed parameters = %d"%len(loc))
nms = lkl["default"].attrs["name"]
nms = [nms[i*256:i*256+256].strip() for i in range(len(loc))]
for n,l in zip(nms,loc):
print(" %s = %g"%(n,l))
ilkl = 0
for lkli_n in ("lkl_%d"%v for v in range(lkl.attrs["n_lkl_object"])):
lkli = lkl[lkli_n]
print("\n %s"%lkli_n)
print(" lkl_type = %s"%lkli.attrs["lkl_type"])
print(" unit = %g"%lkli.attrs["unit"])
if "lmax" in lkli.attrs:
lmax = lkli.attrs["lmax"]
lmin = 0
if "lmin" in lkli.attrs:
lmin = lkli.attrs["lmin"]
ellh = False
else:
ell = lkli.attrs["ell"]
lmax = nm.max(ell)
lmin = nm.min(ell)
ellh = not nm.alltrue((ell[1:]-ell[:-1]) == 1)
print(" "+" ".join([nl+" = [%d , %d]"%(lmin,lmax) for nl,hl in zip(("TT","EE","BB","TE","TB","EB"),lkli.attrs["has_cl"]) if hl ])+" (discontinous)"*ellh)
if "wl" in lkli.attrs:
print(" has window function")
if "nbins" in lkli.attrs:
print(" nbins = %d"%lkli.attrs["nbins"])
if lkli.attrs["lkl_type"]=="smica":
print(" component 0 : CMB")
for nc in range(1,lkli.attrs["n_component"]):
if "component_name" in lkli["component_%d"%nc]:
print(" component %d : %s"%(nc,lkli["component_%d"%nc].attrs["component_name"]))
else:
print(" component %d : %s"%(nc,lkli["component_%d"%nc].attrs["component_type"]))
extn = clikl.get_extra_parameter_names_by_lkl(ilkl)
print(" number of extra parameters = %d %s"%(len(extn),extn))
ilkl +=1
def initialize(self):
if "2015" in self.get_name():
for line in _deprecation_msg_2015.split("\n"):
self.log.warning(line)
code_path = common_path
data_path = get_data_path(self.__class__.get_qualified_class_name())
if self.path:
has_clik = False
else:
try:
import clik
has_clik = True
except ImportError:
clik = None
has_clik = False
if not has_clik:
if not self.path:
if self.packages_path:
self.path_clik = os.path.join(self.packages_path, "code", code_path)
else:
raise LoggedError(
self.log, "No path given to the Planck likelihood. Set the "
"likelihood property 'path' or the common property "
"'%s'.", _packages_path)
else:
self.path_clik = self.path
self.log.info("Importing clik from %s", self.path_clik)
# test and import clik
is_installed_clik(self.path_clik, log_and_fail=True, import_it=False)
import clik
# Loading the likelihood data
if not os.path.isabs(self.clik_file):
self.path_data = getattr(self, "path_data", os.path.join(
self.path or self.packages_path, "data", data_path))
self.clik_file = os.path.join(self.path_data, self.clik_file)
# Differences in the wrapper for lensing and non-lensing likes
self.lensing = clik.try_lensing(self.clik_file)
try:
self.clik = clik.clik_lensing(self.clik_file) if self.lensing \
else clik.clik(self.clik_file)
except clik.lkl.CError:
# Is it that the file was not found?
if not os.path.exists(self.clik_file):
raise LoggedError(
self.log, "The .clik file was not found where specified in the "
"'clik_file' field of the settings of this likelihood. "
"Maybe the 'path' given is not correct? The full path where"
" the .clik file was searched for is '%s'", self.clik_file)
# Else: unknown clik error
self.log.error("An unexpected error occurred in clik (possibly related to "
"multiple simultaneous initialization, or simultaneous "
"initialization of incompatible likelihoods (e.g. polarised "
"vs non-polarised 'lite' likelihoods. See error info below:")
raise
self.l_maxs = self.clik.get_lmax()
# calculate requirements here so class can also be separately instantiated
requested_cls = ["tt", "ee", "bb", "te", "tb", "eb"]
if self.lensing:
has_cl = [lmax != -1 for lmax in self.l_maxs]
requested_cls = ["pp"] + requested_cls
else:
has_cl = self.clik.get_has_cl()
self.requested_cls = [cl for cl, i in zip(requested_cls, has_cl) if int(i)]
self.l_maxs_cls = [lmax for lmax, i in zip(self.l_maxs, has_cl) if int(i)]
self.expected_params = list(self.clik.extra_parameter_names)
# Placeholder for vector passed to clik
length = (len(self.l_maxs) if self.lensing else len(self.clik.get_has_cl()))
self.vector = np.zeros(np.sum(self.l_maxs) + length + len(self.expected_params))
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2018_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2018_DATA is not set.')
### Planck 2018 low ells TT
lell_TT = clik.clik(clik_root + '/low_l/commander/commander_dx12_v3_2_29.clik')
lell_TT_pars = lell_TT.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate(
(class_run.lensed_cl()['tt'][:30] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in lell_TT_pars])))
return lell_TT(args)
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2018_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2018_DATA is not set.')
### Planck 2018 low ells EE, BB
lell_EEBB = clik.clik(
clik_root + '/low_l/simall/simall_100x143_offlike5_EEBB_Aplanck_B.clik')
lell_EEBB_pars = lell_EEBB.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate(
(class_run.lensed_cl()['ee'][:30] * 1e12 * class_run.T_cmb()**2.,
class_run.lensed_cl()['bb'][:30] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in lell_EEBB_pars])))
return lell_EEBB(args)
def initialize(self):
if "2015" in self.name:
for line in _deprecation_msg_2015.split("\n"):
self.log.warning(line)
code_path = common_path
data_path = get_data_path(self.__class__.get_module_name())
if self.path:
has_clik = False
else:
try:
import clik
has_clik = True
except ImportError:
has_clik = False
if not has_clik:
if not self.path:
if self.path_install:
self.path_clik = os.path.join(self.path_install, "code",
code_path)
else:
raise LoggedError(
self.log,
"No path given to the Planck likelihood. Set the "
"likelihood property 'path' or the common property "
"'%s'.", _path_install)
else:
self.path_clik = self.path
self.log.info("Importing clik from %s", self.path_clik)
# test and import clik
is_installed_clik(self.path_clik,
log_and_fail=True,
import_it=False)
import clik
# Loading the likelihood data
if not os.path.isabs(self.clik_file):
self.path_data = getattr(
self, "path_data",
os.path.join(self.path or self.path_install, "data",
data_path))
self.clik_file = os.path.join(self.path_data, self.clik_file)
# Differences in the wrapper for lensing and non-lensing likes
self.lensing = clik.try_lensing(self.clik_file)
try:
self.clik = (clik.clik_lensing(self.clik_file)
if self.lensing else clik.clik(self.clik_file))
except clik.lkl.CError:
# Is it that the file was not found?
if not os.path.exists(self.clik_file):
raise LoggedError(
self.log,
"The .clik file was not found where specified in the "
"'clik_file' field of the settings of this likelihood. Maybe the "
"'path' given is not correct? The full path where the .clik file was "
"searched for is '%s'", self.clik_file)
# Else: unknown clik error
self.log.error(
"An unexpected error occurred in clik (possibly related to "
"multiple simultaneous initialization, or simultaneous "
"initialization of incompatible likelihoods (e.g. polarised "
"vs non-polarised 'lite' likelihoods. See error info below:")
raise
# Check that the parameters are the right ones
self.expected_params = list(self.clik.extra_parameter_names)
differences = are_different_params_lists(self.input_params,
self.expected_params,
name_A="given",
name_B="expected")
if differences:
raise LoggedError(
self.log, "Configuration error in parameters: %r. "
"If this has happened without you fiddling with the defaults, "
"please open an issue in GitHub.", differences)
# Placeholder for vector passed to clik
self.l_maxs = self.clik.get_lmax()
length = (len(self.l_maxs)
if self.lensing else len(self.clik.get_has_cl()))
self.vector = np.zeros(
np.sum(self.l_maxs) + length + len(self.expected_params))
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2015_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2015_DATA is not set.')
### Planck 2015 lite high ells TT, TE, EE
hell_TTTEEElite = clik.clik(clik_root + '/hi_l/plik_lite/plik_lite_v18_TTTEEE.clik')
hell_TTTEEElite_pars = hell_TTTEEElite.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate((
class_run.lensed_cl()['tt'][:2509] * 1e12 * class_run.T_cmb()**2.,
class_run.lensed_cl()['ee'][:2509] * 1e12 * class_run.T_cmb()**2.,
class_run.lensed_cl()['te'][:2509] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in hell_TTTEEElite_pars])
))
return hell_TTTEEElite(args)
def getLk(plikfile):
lkl = cache.get(plikfile, None)
if not lkl:
lkl = clik.clik(plikfile)
cache[plikfile] = lkl
return lkl
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2018_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2018_DATA is not set.')
### Planck 2018 high ells TT
hell_TT = clik.clik(clik_root + '/hi_l/plik/plik_rd12_HM_v22_TT.clik')
hell_TT_pars = hell_TT.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate(
(class_run.lensed_cl()['tt'][:2509] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in hell_TT_pars])))
return hell_TT(args)
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2015_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2015_DATA is not set.')
### Planck 2015 low ells TT, EE, BB
lell_TEB = clik.clik(clik_root +
'/low_l/bflike/lowl_SMW_70_dx11d_2014_10_03_v5c_Ap.clik')
lell_TEB_pars = lell_TEB.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate(
(class_run.lensed_cl()['tt'][:30] * 1e12 * class_run.T_cmb()**2.,
class_run.lensed_cl()['ee'][:30] * 1e12 * class_run.T_cmb()**2.,
class_run.lensed_cl()['bb'][:30] * 1e12 * class_run.T_cmb()**2.,
class_run.lensed_cl()['te'][:30] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in lell_TEB_pars])))
return lell_TEB(args)
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2015_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2015_DATA is not set.')
### Planck 2015 low ells TT
lell_TT = clik.clik(clik_root +
'/low_l/commander/commander_rc2_v1.1_l2_29_B.clik')
lell_TT_pars = lell_TT.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate(
(class_run.lensed_cl()['tt'][:30] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in lell_TT_pars])))
return lell_TT(args)
def change_cls(dffile,bestfit,cls): import clik clo = nm.loadtxt(bestfit) clo[:len(clik.clik(dffile).cc.get_extra_parameter_names())] = cls return cls
def getLk(plikfile):
lkl = cache.get(plikfile, None)
if not lkl:
lkl = clik.clik(plikfile)
cache[plikfile] = lkl
return lkl
def __init__(self,
clik_file,
auto_reject_errors=False,
lensing=None,
**nuisance):
super().__init__(**arguments())
from clik import clik, clik_lensing
if lensing or "lensing" in clik_file:
loaded_cliks[clik_file] = self.clik = loaded_cliks[clik_file] if clik_file in loaded_cliks else clik_lensing(clik_file)
self.lensing = True
self.clik_specs = ['pp'] + clik_specs
else:
loaded_cliks[clik_file] = self.clik = loaded_cliks[clik_file] if clik_file in loaded_cliks else clik(clik_file)
self.lensing = False
self.clik_specs = clik_specs
zcmb, zhel, dz, mb, dmb, x1, dx1, color, dcolor, thirdvar, cov_m_s, cov_m_c, cov_s_c, set_jla = loadtxt('/sto/home/willribeiro/Data/jla_lcparams.txt', usecols=(1,2,3,4,5,6,7,8,9,10,14,15,16,17), unpack=True)
sigma_coh, sigma_lens, zfile = loadtxt('/sto/home/willribeiro/Data/sigma_mu.txt', usecols=(0,1,2), unpack=True)
V0 = sc.genfromtxt('/sto/home/willribeiro/Data/jla_v0_covmatrix.dat')
Va = sc.genfromtxt('/sto/home/willribeiro/Data/jla_va_covmatrix.dat')
Vb = sc.genfromtxt('/sto/home/willribeiro/Data/jla_vb_covmatrix.dat')
V0a = sc.genfromtxt('/sto/home/willribeiro/Data/jla_v0a_covmatrix.dat')
V0b = sc.genfromtxt('/sto/home/willribeiro/Data/jla_v0b_covmatrix.dat')
Vab = sc.genfromtxt('/sto/home/willribeiro/Data/jla_vab_covmatrix.dat')
####################################################################################################################################
#DATA FOR CMB FROM PLANCK LIKELIHOODS
lkl_highl = clik.clik('/sto/home/willribeiro/Data/plik_dx11dr2_HM_v18_TT.clik')
lkl_lowl = clik.clik('/sto/home/willribeiro/Data/lowl_SMW_70_dx11d_2014_10_03_v5c_Ap.clik')
########################################################################################################################################
#DEFINING SOME PARAMETERS
z1, z2, z3, z4, z5, z6, zlim = 0.0, 0.25, 0.50, 0.85, 1.25, 2.0, 2.25 #redshift bins
wlim = -1.0 #limiting w for redshifts higher than zlim
wgamma = 0.00002469 #wgamma for photons, this is well fixed by COBE satellite (Amendola, (2.45))
light = 299792.458 #speed of light in km/s
H0_jla = 70.0 #fiducial H0 value for supernovae (it has no influence on the final results)
cib_index = -1.3 #fixed nuisance from Planck
#Log information from terminal in txt
def __init__(self, clikfile, paramnames=None):
# paramnames will be used to do the mapping to the extra parameters
self.dffile = clikfile
self.name = os.path.splitext(os.path.basename(clikfile))[0]
if isinstance(paramnames, (list, tuple)):
self.parnames = paramnames
else:
if paramnames is None:
# match versions to the baseline .paramnames file
for rem in ['_', 'a_', 'b_', 'c_', 'd_']:
name = self.name.replace(rem, '_').replace('_bin1', '')
paramnames = os.path.join(
os.path.dirname(__file__),
'../../data/' + name + '.paramnames')
if os.path.exists(paramnames):
break
self.paramnamefile = paramnames
self.paramnames = ParamNames(paramnames)
self.parnames = self.paramnames.list()
self.clik = clik.clik(clikfile)
self._translate_parname(self.parnames)
self.fi = hpy.File(self.dffile)
# some metadata
self.hascl = self.fi["clik/lkl_0/has_cl"]
self.lmin = self.fi["clik/lkl_0/lmin"]
self.lmax = self.fi["clik/lkl_0/lmax"]
self.mt = self.fi["clik/lkl_0/m_channel_T"] * self.hascl[0]
self.me = self.fi["clik/lkl_0/m_channel_P"] * self.hascl[1]
self.mb = self.fi["clik/lkl_0/m_channel_P"] * self.hascl[2]
self.m = self.mt + self.me + self.mb
self.nb = self.fi["clik/lkl_0/nbins"] / self.hascl.sum()
self.rq_shape = (self.nb, self.m, self.m)
# binning details
self.blmin = self.fi["clik/lkl_0/bin_lmin"]
self.blmax = self.fi["clik/lkl_0/bin_lmax"]
self.b_ws = self.fi["clik/lkl_0/bin_ws"]
# the binning matrix is also simply obtained this way (but using it is slower than using the binning details, 'cause it's full of zeros)
self.bns = php.read_bins(self.fi["clik/lkl_0"])
# compute the binned ells
self.lm = np.dot(self.bns[:self.nb, :self.lmax - self.lmin + 1],
np.arange(self.lmin, self.lmax + 1))
# get the calibration part (and beam for plik 2015)
# cal and bal are functions that expect a vector of parameters whose name and ordering are given by cal.varpar and bal.varpar
# overal calibration is given by cal(pars)*vec(pars)*outer(acmb,acmb)[nm.newaxis,:,:]
self.cal = smh.calTP_from_smica(self.dffile)
self.bal = smh.beamTP_from_smica(self.dffile)
self.acmb = self.fi["clik/lkl_0/A_cmb"]
# get the binned Cl data array
self.rqh = self.fi["clik/lkl_0/Rq_hat"]
self.rqh.shape = self.rq_shape
# get the additive nuisance components
self.prms = smh.parametric_from_smica(self.dffile)
self.prms_name = [p.get_name() for p in self.prms]
# get the selection vector
self.oo, self.Jt = smh.ordering_from_smica(self.dffile)
# get the inverse covariance
self.siginv = self.fi["clik/lkl_0/criterion_gauss_mat"]
self.siginv.shape = (len(self.oo), len(self.oo))
ls = np.arange(self.lmax + 1)
self.llp1 = ls * (ls + 1) / (2 * np.pi)
self.llp1[0] = 1
self.indices = [(0, 0), (1, 1), (2, 2), (0, 1), (0, 2), (1, 2)]
self.spectra = ["tt", "ee", "bb", "te", "tb", "eb"]
import os
import clik
import numpy as np
### Some important variables ###
clik_root = os.environ.get('PLANCK_2015_DATA')
if clik_root == None:
raise ValueError('The environment variable PLANCK_2015_DATA is not set.')
### Planck 2015 high ells TT
hell_TT = clik.clik(clik_root + '/hi_l/plik/plik_dx11dr2_HM_v18_TT.clik')
hell_TT_pars = hell_TT.get_extra_parameter_names()
def get_loglike(class_input, likes_input, class_run):
args = np.concatenate(
(class_run.lensed_cl()['tt'][:2509] * 1e12 * class_run.T_cmb()**2.,
np.array([likes_input[par] for par in hell_TT_pars])))
return hell_TT(args)
def init(self, p):
import clik
self.files = p.get(('clik','files'),{})
self.cliks = {k:clik.clik(v) for k,v in self.files.items()}
