def calTP0_from_smica(dffile):
import hpy
fi = hpy.File(dffile)
hascl = fi["clik/lkl_0/has_cl"]
nb = fi["clik/lkl_0/nbins"] / hascl.sum()
mt = fi["clik/lkl_0/m_channel_T"] * hascl[0]
me = fi["clik/lkl_0/m_channel_P"] * hascl[1]
mb = fi["clik/lkl_0/m_channel_P"] * hascl[2]
m = mt + me + mb
hgrp = fi["clik/lkl_0"]
nc = hgrp.attrs["n_component"]
prms = []
fnd = False
for i in range(1, nc):
compot = hgrp["component_%d" % i].attrs["component_type"]
if not (compot in ("calTP", "icalTP")):
continue
fnd = True
break
if not fnd:
def cal(vals):
return nm.ones((nb, m, m))
cal.varpar = []
return cal
names = fi["clik/lkl_0/component_%d/names" % i].replace("\0", " ").split()
im = fi["clik/lkl_0/component_%d/im" % i]
if "w" in fi["clik/lkl_0/component_%d" % i]:
w = fi["clik/lkl_0/component_%d/w" % i]
other = fi["clik/lkl_0/component_%d/other" % i]
w.shape = (m, m, 2)
other.shape = (m, m, 2)
else:
w = nm.zeros((m, m, 2), dtype=nm.double)
w[:, :] = [1, 0]
other = nm.indices((m, m)).T[:, :, ::-1]
if compot == "calTP":
Mexp = nm.exp
else:
Mexp = lambda x: 1. / nm.sqrt(x)
def cal(vals):
vec = nm.ones(m)
evals = Mexp(vals)
vec[im[im < mt]] = evals[im < mt]
vec[im[im >= mt]] = evals[im >= mt]
if mb:
vec[im[im >= mt] + mb] = evals[im >= mt]
gmat = nm.outer(vec, vec)
gmat_prime = gmat[other[:, :, 0], other[:, :, 1]]
gmat = w[:, :, 0] * gmat + w[:, :, 1] * gmat_prime
return nm.ones((nb, m, m)) * gmat[nm.newaxis, :, :]
cal.varpar = names
return cal
def remove_selfcheck(fname=None,root_grp=None):
if fname!=None:
hf = hpy.File(fname, 'r+')
root_grp = hf["clik"]
if "check_param" in root_grp:
del root_grp["check_param"]
if "check_value" in root_grp:
del root_grp["check_value"]
if fname:
hf.close()
def baseCreateParobject(parobject):
# init file
hf = hpy.File(parobject, 'w')
root_grp = hf.create_group("clik")
# fill general info
root_grp.attrs["n_lkl_object"] = 0
root_grp.attrs["lmax"] = [-1,-1,-1,-1,-1,-1]
return root_grp,hf
def add_selfcheck(fname,pars):
import lkl
mlkl = lkl.clik(fname)
res = mlkl(pars)
del(mlkl)
# add check pars
hf = hpy.File(fname, 'r+')
root_grp = hf["clik"]
root_grp.create_dataset("check_param",data=pars)
root_grp.attrs["check_value"] = float(res)
hf.close()
return res
def get_bestfit_and_cl(dffile, bffile):
import hpy
import lkl
fi = hpy.File(dffile)
bff = nm.loadtxt(bffile)
lmax = fi["clik/lkl_0/lmax"]
hascl = fi["clik/lkl_0/has_cl"]
cls = nm.zeros((6, lmax + 1))
cnt = 0
for i in range(6):
if hascl[i]:
cls[i] = bff[cnt:cnt + lmax + 1]
cnt += lmax + 1
lkl = lkl.clik(dffile)
names = lkl.extra_parameter_names
bestfit = dict(zip(names, bff[cnt:]))
return bestfit, cls
def calTP_from_smica(dffile):
cal0 = calTP0_from_smica(dffile)
import hpy
fi = hpy.File(dffile)
hascl = fi["clik/lkl_0/has_cl"]
nb = fi["clik/lkl_0/nbins"] / hascl.sum()
mt = fi["clik/lkl_0/m_channel_T"] * hascl[0]
me = fi["clik/lkl_0/m_channel_P"] * hascl[1]
mb = fi["clik/lkl_0/m_channel_P"] * hascl[2]
m = mt + me + mb
hgrp = fi["clik/lkl_0"]
nc = hgrp.attrs["n_component"]
fnd = 0
TP = {"T": "", "P": ""}
for i in range(1, nc):
compot = hgrp["component_%d" % i].attrs["component_type"]
if compot == "totcal":
TP["T"] = hgrp["component_%d" % i].attrs["calname"]
fnd += 1
if compot == "totcalP":
TP["P"] = hgrp["component_%d" % i].attrs["calnameP"]
fnd += 1
if fnd == 2:
break
if fnd == 0:
return cal0
def cal(vals):
rqd = cal0(vals[:-fnd])
if TP["P"]:
calP = 1. / (vals[-fnd])
rP = nm.ones((m, m))
rP[:mt, mt:] = calP
rP[mt:, :mt] = calP
rP[mt:, mt:] = calP**2
rqd = rqd * rP[nm.newaxis, :, :]
if TP["T"]:
calT = 1. / vals[-1]
rqd = rqd * calT**2
return rqd
cal.varpar = [v for v in list(cal0.varpar) + [TP["P"]] + [TP["T"]] if v]
return cal
def beamTP_from_smica(dffile):
import hpy
fi = hpy.File(dffile)
hascl = fi["clik/lkl_0/has_cl"]
nb = fi["clik/lkl_0/nbins"] / hascl.sum()
mt = fi["clik/lkl_0/m_channel_T"] * hascl[0]
me = fi["clik/lkl_0/m_channel_P"] * hascl[1]
mb = fi["clik/lkl_0/m_channel_P"] * hascl[2]
m = mt + me + mb
hgrp = fi["clik/lkl_0"]
nc = hgrp.attrs["n_component"]
prms = []
fnd = False
for i in range(1, nc):
compot = hgrp["component_%d" % i].attrs["component_type"]
if not (compot == "beamTP"):
continue
fnd = True
break
if not fnd:
def cal(vals):
return nm.ones((nb, m, m))
cal.varpar = []
return cal
names = fi["clik/lkl_0/component_%d/names" % i].replace("\0", " ").split()
neigen = fi["clik/lkl_0/component_%d/neigen" % i]
im = fi["clik/lkl_0/component_%d/im" % i]
im.shape = (m, m, neigen)
modes = fi["clik/lkl_0/component_%d/modes" % i]
modes.shape = (nb, m, m, neigen)
def cal(vals):
nals = nm.concatenate(([0.], vals))
calpars = nals[im]
return nm.exp(nm.sum(calpars[nm.newaxis, :, :, :] * modes, 3))
cal.varpar = names
return cal
def ordering_from_smica(dffile, jac=True):
import hpy
fi = hpy.File(dffile)
msk = fi["clik/lkl_0/criterion_gauss_mask"]
ord = fi["clik/lkl_0/criterion_gauss_ordering"]
hascl = fi["clik/lkl_0/has_cl"]
mT = fi["clik/lkl_0/m_channel_T"]
mP = fi["clik/lkl_0/m_channel_P"]
mE = mT * hascl[0]
mB = mE + mP * hascl[1]
m = mB + mP * hascl[2]
#print mT,mP,mE,mB,m
#print hascl
nb = fi["clik/lkl_0/nbins"] / hascl.sum()
m2 = m * m
ordr = nm.concatenate([
nm.arange(nb)[msk[iv + jv * m::m2] == 1] * m2 + iv * m + jv
for iv, jv in zip(ord[::2], ord[1::2])
])
if jac == True:
Jt = []
ps = ordr // m2
ii = (ordr % m2) // m
jj = (ordr % m2) % m
ii_T = ii < mE
jj_T = jj < mE
ii_E = (ii >= mE) * (ii < mB)
jj_E = (jj >= mE) * (jj < mB)
ii_B = (ii >= mB) * (ii < m)
jj_B = (jj >= mB) * (jj < m)
if hascl[0]:
#print (ii_T)[ps==0]
#print (jj_T)[ps==0]
#print (ii_T*jj_T)[ps==0]
jac = nm.array([(ps == i) * ii_T * jj_T for i in range(nb)],
dtype=nm.int)
#print jac.sum(1)
Jt += [jac]
if hascl[1]:
jac = nm.array([(ps == i) * ii_E * jj_E for i in range(nb)],
dtype=nm.int)
Jt += [jac]
if hascl[2]:
jac = nm.array([(ps == i) * ii_B * jj_B for i in range(nb)],
dtype=nm.int)
Jt += [jac]
if hascl[3]:
TE = (ii_T * jj_E) + (ii_E * jj_T)
jac = nm.array([(ps == i) * TE for i in range(nb)], dtype=nm.int)
Jt += [jac]
if hascl[4]:
TB = (ii_T * jj_B) + (ii_B * jj_T)
jac = nm.array([(ps == i) * TB for i in range(nb)], dtype=nm.int)
Jt += [jac]
if hascl[5]:
EB = (ii_E * jj_B) + (ii_B * jj_E)
jac = nm.array([(ps == i) * EB for i in range(nb)], dtype=nm.int)
Jt += [jac]
return ordr, nm.concatenate(Jt)
#return ordr,nm.array([ordr/m2==i for i in range(nb)],dtype=nm.int)
fi.close()
def parametric_from_smica(h5file, lmin=-1, lmax=-1, ilkl=0):
import hpy
ff = hpy.File(h5file, "r")
return parametric_from_smica_group(ff["clik/lkl_%d" % ilkl], lmin, lmax)
ff.close()
def best_fit_cmb(dffile, bestfit, cty="B"):
import parobject as php
import hpy
import lkl
import time
oo, Jt0 = ordering_from_smica(dffile)
fi = hpy.File(dffile)
siginv = fi["clik/lkl_0/criterion_gauss_mat"]
siginv.shape = (len(oo), len(oo))
lm, oqb, nrms, rqh, rq = get_binned_calibrated_model_and_data(
dffile, bestfit)
hascl = fi["clik/lkl_0/has_cl"]
tm = nm.concatenate([lm for h in hascl if h])
good = Jt0.sum(1) != 0
Jt = Jt0[good]
Yo = nm.sum(oqb, 0) - rqh
Yo = Yo.flat[oo]
if cty == "B":
a = time.time()
Jt_siginv = nm.zeros((Jt.shape))
w0, w1 = nm.where(Jt != 0)
for ii in range(len(w0)):
i = w0[ii]
j = w1[ii]
Jt_siginv[i] += siginv[j]
print "pcompute Jt_siginv in %d sec" % (time.time() - a)
b = time.time()
Jt_siginv_Yo = nm.dot(Jt_siginv, Yo)
print "pcompute Jt_siginv_Yo in %d sec" % (time.time() - b)
c = time.time()
nl = Jt.shape[0]
Jt_siginv_J = nm.zeros((nl, nl))
for ii in range(len(w0)):
j = w0[ii]
i = w1[ii]
Jt_siginv_J[j] += Jt_siginv[:, i]
print "pcompute Jt_siginv_Yo in %d sec" % (time.time() - c)
#Jt_siginv,Jt_siginv_Yo,Jt_siginv_J = lkl.full_solve(Yo,Jt,siginv)
#rVec = -lkl.chol_solve(Jt_siginv_J,Jt_siginv_Yo),1./nm.sqrt(Jt_siginv_J.diagonal())
rVec = -nm.linalg.solve(Jt_siginv_J, Jt_siginv_Yo), 1. / nm.sqrt(
Jt_siginv_J.diagonal())
print time.time() - a
else:
a = time.time()
Jt_siginv = nm.dot(Jt, siginv)
Jt_siginv_Yo = nm.dot(Jt_siginv, Yo)
Jt_siginv_J = nm.dot(Jt_siginv, Jt.T)
#rVec = -lkl.chol_solve(Jt_siginv_J,Jt_siginv_Yo),1./nm.sqrt(Jt_siginv_J.diagonal())
rVec = -nm.linalg.solve(Jt_siginv_J, Jt_siginv_Yo), 1. / nm.sqrt(
Jt_siginv_J.diagonal())
print time.time() - a
#rVec = -nm.linalg.solve(Jt_siginv_J,Jt_siginv_Yo),1./nm.sqrt(Jt_siginv_J.diagonal())
##try:
## import scipy.linalg as sla
## cho_fac = sla.cho_factor(Jt_siginv_J)
## rVec = -sla.cho_solve(cho_fac,Jt_siginv_Yo),1./nm.sqrt(Jt_siginv_J.diagonal())
##except Exception,e:
## rVec = -nm.linalg.solve(Jt_siginv_J,Jt_siginv_Yo),1./nm.sqrt(Jt_siginv_J.diagonal())
tVec = nm.zeros(len(tm))
eVec = tVec * 0.
tVec[good] = rVec[0]
eVec[good] = rVec[1]
tm.shape = (-1, len(lm))
tVec.shape = tm.shape
eVec.shape = tm.shape
return tm, tVec, eVec
def get_binned_calibrated_model_and_data(dffile, bestfit, cls=None):
import hpy
if isinstance(bestfit, str):
bestfit, cls = get_bestfit_and_cl(dffile, bestfit)
fi = hpy.File(dffile)
cal = calTP_from_smica(dffile)
cvec = [bestfit[nn] for nn in cal.varpar]
g = cal(cvec)
bal = beamTP_from_smica(dffile)
cvec = [bestfit[nn] for nn in bal.varpar]
bg = bal(cvec)
g *= bg
acmb = fi["clik/lkl_0/A_cmb"]
g *= nm.outer(acmb, acmb)[nm.newaxis, :, :]
rqh = fi["clik/lkl_0/Rq_hat"]
rqh.shape = g.shape
# don't rescale the data
#rqh/=g
prms = parametric_from_smica(dffile)
oq = []
nrms = []
for p in prms:
print p
pvec = [bestfit[nn] for nn in p.varpar]
oq += [p(pvec)]
if oq[-1].shape[1:] != rqh.shape[1:]:
bet = nm.zeros((oq[-1].shape[0], rqh.shape[1], rqh.shape[1]))
bet[:, :oq[-1].shape[1], :oq[-1].shape[1]] = oq[-1]
oq[-1] = bet
nrms += [p.__class__.__name__]
oq = nm.array(oq)
blmin = fi["clik/lkl_0/bin_lmin"]
blmax = fi["clik/lkl_0/bin_lmax"]
b_ws = fi["clik/lkl_0/bin_ws"]
hascl = fi["clik/lkl_0/has_cl"]
lmin = fi["clik/lkl_0/lmin"]
lmax = fi["clik/lkl_0/lmax"]
nb = fi["clik/lkl_0/nbins"] / hascl.sum()
mt = fi["clik/lkl_0/m_channel_T"] * hascl[0]
me = fi["clik/lkl_0/m_channel_P"] * hascl[1]
mb = fi["clik/lkl_0/m_channel_P"] * hascl[2]
m = mt + me + mb
oqb = nm.zeros((len(oq), ) + rqh.shape)
lm = nm.zeros(nb)
print oq.shape, oq.shape[0]
for b in range(nb):
if oq.shape[0]:
oqb[:, b] = nm.sum(
oq[:, blmin[b]:blmax[b] + 1] *
b_ws[nm.newaxis, blmin[b]:blmax[b] + 1, nm.newaxis,
nm.newaxis], 1)
lm[b] += nm.sum(
nm.arange(lmin + blmin[b], lmin + blmax[b] + 1) *
b_ws[blmin[b]:blmax[b] + 1])
res = lm, oqb, nrms, rqh
if cls != None:
rq = nm.zeros((nb, m, m))
for b in range(nb):
if mt:
rq[b, :mt, :mt] += nm.sum(
cls[0, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
if me:
rq[b, :mt, mt:mt + me] += nm.sum(
cls[3, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
rq[b, mt:mt + me, :mt] += nm.sum(
cls[3, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
if mb:
rq[b, :mt, mt + me:mb + mt + me] += nm.sum(
cls[4, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
rq[b, mt + me:mb + mt + me, :mt] += nm.sum(
cls[4, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
if me:
rq[b, mt:mt + me, mt:mt +
me] += nm.sum(cls[1, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
if mb:
rq[b, mt:mt + me, mt + me:mb + mt + me] += nm.sum(
cls[5, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
rq[b, mt + me:mb + mt + me, mt:mt + me] += nm.sum(
cls[5, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
if mb:
rq[b, mt + me:mt + me + mb, mt + me:mb + mt +
me] += nm.sum(cls[2, lmin + blmin[b]:lmin + blmax[b] + 1] *
b_ws[blmin[b]:blmax[b] + 1])
#rescale le model stupid !
oqb = nm.array([g * oo for oo in oqb])
rq = rq * g
res = lm, oqb, nrms, rqh, rq
return res
def simulate_chanels(dffile, bestfit, cls, calib=True, nside=2048, all=False):
import hpy
if isinstance(bestfit, str):
bestfit, cls = get_bestfit_and_cl(dffile, bestfit)
fi = hpy.File(dffile)
cal = calTP_from_smica(dffile)
cvec = [bestfit[nn] for nn in cal.varpar]
if not calib:
cvec = cvec * 0
g = nm.sqrt(cal(cvec)[0].diagonal())
hascl = fi["clik/lkl_0/has_cl"]
lmin = fi["clik/lkl_0/lmin"]
lmax = fi["clik/lkl_0/lmax"]
nb = fi["clik/lkl_0/nbins"] / hascl.sum()
mt = fi["clik/lkl_0/m_channel_T"] * hascl[0]
me = fi["clik/lkl_0/m_channel_P"] * hascl[1]
mb = fi["clik/lkl_0/m_channel_P"] * hascl[2]
m = mt + me + mb
import healpy as hp
#icls = [-1,-1,-1,-1,-1,-1]
#if mt!=0:
# icls[0] = 0
#if me!=0:
# icls[1] = 1
#if mt!=[0]:
# icls[2] = 2
#if mt*me != 0:
# icls[3] = 3
#if mt*mb !=0:
# icls[4] = 5
#if me*mb !=0:
# icls[5] = 4
#ncls = [cls[i] if cls[i].sum() else None for i in icls if i!=-1]
icls = [0, 1, 2, 3, 5, 4]
ncls = [cls[i] for i in icls]
if me == 0 and mb == 0:
icls = [0]
print "generate cmb"
cmb = hp.synfast(ncls, nside, pol=True and len(ncls) > 1, new=True)
# got maps for the cmb !
prms = parametric_from_smica(dffile)
oq = []
nrms = []
for p in prms:
pvec = [bestfit[nn] for nn in p.varpar]
oq += [p(pvec)]
nrms += [p.__class__.__name__]
oq = nm.array(oq)
oq = nm.sum(oq, 0)
print "generate fg"
fg = _simu_from_rq(mt, me, mb, oq, nside)
maps = [[None, None, None]] * max(mt, me, mb)
for i in range(mt):
maps[i][0] = (cmb[0] + fg[i][0]) * g[i]
for j in range(max(me, mb)):
maps[i][1] = (cmb[1] + fg[i][1]) * g[i + mt]
maps[i][2] = (cmb[2] + fg[i][2]) * g[i + mt]
if all:
return maps, cmb, fg, g
return maps
def copy_and_get_0(pars):
if "input_object" in pars:
hpy.copyfile(pars.input_object,pars.res_object)
outhf = hpy.File(pars.res_object,"r+")
return outhf,outhf["clik/lkl_%d"%pars.int(default=0).lkl_id]
