def __init__(self,
lib_dir,
sim_lib,
cinv_t,
cinv_p,
cl_weights,
soltn_lib=None):
self.cinv_t = cinv_t
self.cinv_p = cinv_p
super(library_cinv_sepTP, self).__init__(lib_dir,
sim_lib,
cl_weights,
soltn_lib=soltn_lib)
if mpi.rank == 0:
fname_mask = os.path.join(self.lib_dir, "fmask.fits.gz")
if not os.path.exists(fname_mask):
fmask = self.cinv_t.get_fmask()
assert np.all(fmask == self.cinv_p.get_fmask())
hp.write_map(fname_mask, fmask)
mpi.barrier()
utils.hash_check(
pk.load(open(os.path.join(lib_dir, "filt_hash.pk"), 'rb')),
self.hashdict())
def __init__(self, fname, idtype="INTEGER"):
if not os.path.exists(fname) and mpi.rank == 0:
con = sqlite3.connect(fname, detect_types=sqlite3.PARSE_DECLTYPES, timeout=3600)
cur = con.cursor()
cur.execute("create table rngdb (id %s PRIMARY KEY, "
"type STRING, pos INTEGER, has_gauss INTEGER,cached_gaussian REAL, keys STRING)" % idtype)
con.commit()
mpi.barrier()
self.con = sqlite3.connect(fname, timeout=3600., detect_types=sqlite3.PARSE_DECLTYPES)
def __init__(self, sims_cmb_len, cl_transf, nside=2048, lib_dir=None):
self.sims_cmb_len = sims_cmb_len
self.cl_transf = cl_transf
self.nside = nside
if lib_dir is not None:
fn_hash = os.path.join(lib_dir, 'sim_hash.pk')
if mpi.rank == 0 and not os.path.exists(fn_hash):
pk.dump(self.hashdict(), open(fn_hash, 'wb'), protocol=2)
mpi.barrier()
hash_check(self.hashdict(), pk.load(open(fn_hash, 'rb')))
def __init__(self,
lib_dir,
lmax,
nside,
cl,
transf,
ninv,
pcf='default',
chain_descr=None):
assert lib_dir is not None and lmax >= 1024 and nside >= 512, (lib_dir,
lmax,
nside)
super(cinv_p, self).__init__(lib_dir, lmax)
self.nside = nside
self.cl = cl
self.transf = transf
self.ninv = ninv
pcf = os.path.join(lib_dir, "dense.pk") if pcf == 'default' else None
if chain_descr is None: chain_descr = \
[[2, ["split(dense(" + pcf + "), 32, diag_cl)"], 512, 256, 3, 0.0, cd_solve.tr_cg,cd_solve.cache_mem()],
[1, ["split(stage(2), 512, diag_cl)"], 1024, 512, 3, 0.0, cd_solve.tr_cg, cd_solve.cache_mem()],
[0, ["split(stage(1), 1024, diag_cl)"], lmax, nside, np.inf, 1.0e-5, cd_solve.tr_cg, cd_solve.cache_mem()]]
n_inv_filt = util.jit(opfilt_pp.alm_filter_ninv, ninv,
transf[0:lmax + 1])
self.chain = util.jit(multigrid.multigrid_chain, opfilt_pp,
chain_descr, cl, n_inv_filt)
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(os.path.join(lib_dir, "filt_hash.pk")):
pk.dump(self.hashdict(),
open(os.path.join(lib_dir, "filt_hash.pk"), 'wb'),
protocol=2)
if not os.path.exists(os.path.join(self.lib_dir, "fbl.dat")):
fel, fbl = self._calc_febl()
np.savetxt(os.path.join(self.lib_dir, "fel.dat"), fel)
np.savetxt(os.path.join(self.lib_dir, "fbl.dat"), fbl)
if not os.path.exists(os.path.join(self.lib_dir, "tal.dat")):
np.savetxt(os.path.join(self.lib_dir, "tal.dat"),
self._calc_tal())
if not os.path.exists(os.path.join(self.lib_dir, "fmask.fits.gz")):
hp.write_map(os.path.join(self.lib_dir, "fmask.fits.gz"),
self._calc_mask())
mpi.barrier()
utils.hash_check(
pk.load(open(os.path.join(lib_dir, "filt_hash.pk"), 'rb')),
self.hashdict())
def __init__(self, lib_dir, qcls_lib):
self.lib_dir = lib_dir
self.qclibs = qcls_lib
hname = os.path.join(lib_dir, 'qeclav_hash.pk')
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(hname):
pk.dump(self.hashdict(), open(hname, 'wb'), protocol=2)
mpi.barrier()
utils.hash_check(pk.load(open(hname, 'rb')), self.hashdict())
def __init__(self, lib_dir, qcls_lib):
self.lib_dir = lib_dir
self.qclibs = qcls_lib
hname = os.path.join(lib_dir, 'qeclav_hash.pk')
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(hname):
pk.dump(self.hashdict(), open(hname, 'wb'), protocol=2)
mpi.barrier()
utils.hash_check(pk.load(open(hname, 'rb')), self.hashdict())
self.mc_sims_mf = np.sort(
np.unique(np.concatenate([qcl.mc_sims_mf for qcl in self.qclibs])))
def __init__(self, fname, idtype="STRING"):
if not os.path.exists(fname) and mpi.rank == 0:
con = sqlite3.connect(fname,
detect_types=sqlite3.PARSE_DECLTYPES,
timeout=3600)
cur = con.cursor()
cur.execute("CREATE TABLE fldb (id %s PRIMARY KEY, fl REAL)" %
idtype)
con.commit()
mpi.barrier()
self.con = sqlite3.connect(fname,
timeout=3600.,
detect_types=sqlite3.PARSE_DECLTYPES)
def __init__(self, lib_dir, get_state_func=np.random.get_state, nsims_max=None):
if not os.path.exists(lib_dir) and mpi.rank == 0:
os.makedirs(lib_dir)
self.nmax = nsims_max
fn_hash = os.path.join(lib_dir, 'sim_hash.pk')
if mpi.rank == 0 and not os.path.exists(fn_hash):
pk.dump(self.hashdict(), open(fn_hash, 'wb'), protocol=2)
mpi.barrier()
hsh = pk.load(open(fn_hash, 'rb'))
utils.hash_check(hsh, self.hashdict(), ignore=['lib_dir'])
self._rng_db = rng_db(os.path.join(lib_dir, 'rngdb.db'), idtype='INTEGER')
self._get_rng_state = get_state_func
def __init__(self, lib_dir, ivfs1, ivfs2, nside, clte=None, lmax_qlm=None, resplib=None):
if lmax_qlm is None:
lmax_qlm = 3 * nside -1
self.lib_dir = lib_dir
self.prefix = lib_dir
self.lmax_qlm = {'T': lmax_qlm, 'P': lmax_qlm, 'PS': lmax_qlm}
if clte is None:
self.f2map1 = lib_filt2map(ivfs1, nside)
self.f2map2 = lib_filt2map(ivfs2, nside)
else:
self.f2map1 = lib_filt2map_sepTP(ivfs1, nside, clte)
self.f2map2 = lib_filt2map_sepTP(ivfs2, nside, clte)
assert self.lmax_qlm['T'] == self.lmax_qlm['P'], 'implement this'
fnhash = os.path.join(self.lib_dir, "qe_sim_hash.pk")
if (mpi.rank == 0) and (not os.path.exists(fnhash)):
if not os.path.exists(self.lib_dir): os.makedirs(self.lib_dir)
pk.dump(self.hashdict(), open(fnhash, 'wb'), protocol=2)
mpi.barrier()
ut.hash_check(pk.load(open(fnhash, 'rb')), self.hashdict())
if mpi.rank == 0:
if not os.path.exists(os.path.join(lib_dir, 'fskies.dat')):
print("Caching sky fractions...")
ms = {1: self.get_mask(1), 2: self.get_mask(2)}
fskies = {}
for i in [1, 2]:
for j in [1, 2][i - 1:]:
fskies[10 * i + j] = np.mean(ms[i] * ms[j])
with open(os.path.join(lib_dir, 'fskies.dat'), 'w') as f:
for lab, _f in zip(np.sort(list(fskies.keys())),
np.array(list(fskies.values()))[np.argsort(list(fskies.keys()))]):
f.write('%4s %.5f \n' % (lab, _f))
mpi.barrier()
fskies = {}
with open(os.path.join(lib_dir, 'fskies.dat')) as f:
for line in f:
(key, val) = line.split()
fskies[int(key)] = float(val)
self.fskies = fskies
self.fsky11 = fskies[11]
self.fsky12 = fskies[12]
self.fsky22 = fskies[22]
self.resplib = resplib
self.keys_fund = ['ptt', 'xtt', 'p_p', 'x_p', 'p', 'x', 'stt', 'ftt','f_p', 'f','dtt', 'ntt', 'a_p',
'pte', 'pet', 'ptb', 'pbt', 'pee', 'peb', 'pbe', 'pbb',
'xte', 'xet', 'xtb', 'xbt', 'xee', 'xeb', 'xbe', 'xbb']
self.keys = self.keys_fund + ['p_tp', 'x_tp', 'p_te', 'p_tb', 'p_eb', 'x_te', 'x_tb', 'x_eb', 'ptt_bh_n',
'ptt_bh_s', 'ptt_bh_f', 'ptt_bh_d', 'dtt_bh_p', 'stt_bh_p', 'ftt_bh_d']
def __init__(self, lib_dir, qeA, qeB, mc_sims_mf):
self.lib_dir = lib_dir
self.prefix = lib_dir
self.qeA = qeA
self.qeB = qeB
self.mc_sims_mf = mc_sims_mf
fsname = os.path.join(lib_dir, 'fskies.dat')
hname = os.path.join(self.lib_dir, 'qcl_sim_hash.pk')
if mpi.rank == 0:
if not os.path.exists(lib_dir): os.makedirs(lib_dir)
if not os.path.exists(fsname):
print('Caching sky fractions...')
ms = {
1: self.qeA.get_mask(1),
2: self.qeA.get_mask(2),
3: self.qeB.get_mask(1),
4: self.qeB.get_mask(2)
}
assert np.all([m.shape == ms[1].shape for m in ms.values()
]), (m.shape for m in ms.values())
fskies = {}
for i in [1, 2, 3, 4]:
for j in [1, 2, 3, 4][i - 1:]:
fskies[10 * i + j] = np.mean(ms[i] * ms[j])
fskies[1234] = np.mean(ms[1] * ms[2] * ms[3] * ms[4])
with open(fsname, 'w') as f:
for lab, _f in zip(
np.sort(list(fskies.keys())),
np.array(list(fskies.values()))[np.argsort(
list(fskies.keys()))]):
f.write('%4s %.5f \n' % (lab, _f))
if not os.path.exists(hname):
if not os.path.exists(self.lib_dir):
os.makedirs(self.lib_dir)
pk.dump(self.hashdict(), open(hname, 'wb'), protocol=2)
mpi.barrier()
utils.hash_check(pk.load(open(hname, 'rb')), self.hashdict())
self.npdb = sql.npdb(os.path.join(lib_dir, 'cldb.db'))
fskies = {}
with open(fsname) as f:
for line in f:
(key, val) = line.split()
fskies[int(key)] = float(val)
self.fskies = fskies
self.fsky1234 = fskies[1234]
self.fsky11 = fskies[11]
self.fsky12 = fskies[12]
self.fsky22 = fskies[22]
def __init__(self, lib_dir, sim_lib, cl_weights, soltn_lib=None, cache=True):
self.lib_dir = lib_dir
self.sim_lib = sim_lib
self.cl = cl_weights
self.soltn_lib = soltn_lib
self.cache = cache
fn_hash = os.path.join(lib_dir, 'filt_hash.pk')
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(fn_hash):
pk.dump(self.hashdict(), open(fn_hash, 'wb'), protocol=2)
mpi.barrier()
utils.hash_check(pk.load(open(fn_hash, 'rb')), self.hashdict())
def __init__(self, lib_dir, lmax_ivf, cls_weight, cls_cmb, fal, lmax_qlm):
self.lmax_qe = lmax_ivf
self.lmax_qlm = lmax_qlm
self.cls_weight = cls_weight
self.cls_cmb = cls_cmb
self.fal = fal
self.lib_dir = lib_dir
fn_hash = os.path.join(lib_dir, 'resp_hash.pk')
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(fn_hash):
pk.dump(self.hashdict(), open(fn_hash, 'wb'), protocol=2)
mpi.barrier()
ut.hash_check(pk.load(open(fn_hash, 'rb')), self.hashdict())
self.npdb = sql.npdb(os.path.join(lib_dir, 'npdb.db'))
def __init__(self, lib_dir, ivfs, cls_weight, lmax_qlm, resplib=None):
self.lmax_qlm = lmax_qlm
self.cls_weight = cls_weight
self.ivfs = ivfs
fn_hash = os.path.join(lib_dir, 'nhl_hash.pk')
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(fn_hash):
pk.dump(self.hashdict(), open(fn_hash, 'wb'), protocol=2)
mpi.barrier()
utils.hash_check(pk.load(open(fn_hash, 'rb')), self.hashdict())
self.lib_dir = lib_dir
self.npdb = sql.npdb(os.path.join(lib_dir, 'npdb.db'))
self.fsky = np.mean(self.ivfs.get_fmask())
self.resplib = resplib
def __init__(self,
lib_dir,
lmax,
cls_unl,
lib_pha=None,
dlmax=1024,
nside_lens=4096,
facres=0,
nbands=16,
verbose=True):
if not os.path.exists(lib_dir) and mpi.rank == 0:
os.makedirs(lib_dir)
mpi.barrier()
fields = _get_fields(cls_unl)
if lib_pha is None and mpi.rank == 0:
lib_pha = phas.lib_phas(os.path.join(lib_dir, 'phas'), len(fields),
lmax + dlmax)
else: # Check that the lib_alms are compatible :
assert lib_pha.lmax == lmax + dlmax
mpi.barrier()
self.lmax = lmax
self.dlmax = dlmax
# lenspyx parameters:
self.nside_lens = nside_lens
self.nbands = nbands
self.facres = facres
self.unlcmbs = sims_cmb_unl(cls_unl, lib_pha)
self.lib_dir = lib_dir
self.fields = _get_fields(cls_unl)
fn_hash = os.path.join(lib_dir, 'sim_hash.pk')
if mpi.rank == 0 and not os.path.exists(fn_hash):
pk.dump(self.hashdict(), open(fn_hash, 'wb'), protocol=2)
mpi.barrier()
utils.hash_check(self.hashdict(), pk.load(open(fn_hash, 'rb')))
try:
import lenspyx
except ImportError:
print("Could not import lenspyx module")
lenspyx = None
self.lens_module = lenspyx
self.verbose = verbose
if args.ivt:
jobs += [(idx, 't') for idx in range(args.imin, args.imax + 1)]
if args.ds and args.imin >= 0: # Make data to avoid problems with ds librairies
jobs += [(-1, 't')]
if args.ivp:
jobs += [(idx, 'p') for idx in range(args.imin, args.imax + 1)]
if args.ds and args.imin >= 0: # Make data to avoid problems with ds librairies
jobs += [(-1, 'p')]
for i, (idx, lab) in enumerate(jobs[mpi.rank::mpi.size]):
print('rank %s filtering sim %s %s, job %s in %s' %
(mpi.rank, idx, lab, i, len(jobs)))
if lab == 't':
par.ivfs.get_sim_tlm(idx)
elif lab == 'p':
par.ivfs.get_sim_elm(idx) # This will cache blm as well.
mpi.barrier()
# --- unnormalized QE calculation
qlibs = [par.qlms_dd] * args.dd + [par.qlms_ss] * args.ss + [par.qlms_ds
] * args.ds
jobs = []
for qlib in qlibs:
for k in args.k:
jobs += [(qlib, idx, k) for idx in range(args.imin, args.imax + 1)]
for i, (qlib, idx, k) in enumerate(jobs[mpi.rank::mpi.size]):
print('rank %s doing QE sim %s %s, qlm_lib %s, job %s in %s' %
(mpi.rank, idx, k, qlib.lib_dir, i, len(jobs)))
qlib.get_sim_qlm(k, idx)
mpi.barrier()
def __init__(self,
lib_dir,
lmax,
nside,
cl,
transf,
ninv,
marge_maps_t=(),
marge_monopole=False,
marge_dipole=False,
pcf='default',
rescal_cl='default'):
"""Instance for joint temperature-polarization filtering
Here ninv is a list of lists with mask paths and / or inverse pixel noise levels.
TT, (QQ + UU) / 2 if len(ninv) == 2 or TT, QQ, QU UU if == 4
e.g. [[iNevT,mask1,mask2,..],[iNevP,mask1,mask2...]]
"""
assert (lmax >= 1024)
assert (nside >= 512)
assert len(
ninv) == 2 or len(ninv) == 4 # TT, (QQ + UU)/2 or TT,QQ,QU,UU
if rescal_cl == 'default':
rescal_cl = np.sqrt(
np.arange(lmax + 1, dtype=float) *
np.arange(1, lmax + 2, dtype=float) / 2. / np.pi)
elif rescal_cl is None:
rescal_cl = np.ones(lmax + 1, dtype=float)
dl = {k: rescal_cl**2 * cl[k][:lmax + 1]
for k in cl.keys()} # rescaled cls (Dls by default)
transf_dl = transf[:lmax + 1] * utils.cli(rescal_cl)
self.lmax = lmax
self.nside = nside
self.cl = cl
self.transf = transf
self.ninv = ninv
self.marge_maps_t = marge_maps_t
self.marge_maps_p = []
self.lib_dir = lib_dir
self.rescal_cl = rescal_cl
pcf = lib_dir + "/dense_tp.pk" if pcf == 'default' else None
chain_descr = [[
3, ["split(dense(" + pcf + "), 64, diag_cl)"], 256, 128, 3, 0.0,
cd_solve.tr_cg,
cd_solve.cache_mem()
],
[
2, ["split(stage(3), 256, diag_cl)"], 512, 256, 3,
0.0, cd_solve.tr_cg,
cd_solve.cache_mem()
],
[
1, ["split(stage(2), 512, diag_cl)"], 1024, 512, 3,
0.0, cd_solve.tr_cg,
cd_solve.cache_mem()
],
[
0, ["split(stage(1), 1024, diag_cl)"], lmax, nside,
np.inf, 1.0e-5, cd_solve.tr_cg,
cd_solve.cache_mem()
]]
n_inv_filt = util.jit(opfilt_tp.alm_filter_ninv,
ninv,
transf_dl,
marge_maps_t=marge_maps_t,
marge_monopole=marge_monopole,
marge_dipole=marge_dipole)
self.chain = util.jit(multigrid.multigrid_chain, opfilt_tp,
chain_descr, dl, n_inv_filt)
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(os.path.join(lib_dir, "filt_hash.pk")):
pk.dump(self.hashdict(),
open(os.path.join(lib_dir, "filt_hash.pk"), 'wb'),
protocol=2)
# if (not os.path.exists(self.lib_dir + "/fbl.dat")):
# fel, fbl = self.calc_febl()
# fel.write(self.lib_dir + "/fel.dat", lambda l: 1.0)
# fbl.write(self.lib_dir + "/fbl.dat", lambda l: 1.0)
# if (not os.path.exists(self.lib_dir + "/tal.dat")):
# tal = self.calc_tal()
# tal.write(self.lib_dir + "/tal.dat", lambda l: 1.0)
if not os.path.exists(os.path.join(self.lib_dir, "fmask.fits.gz")):
fmask = self.calc_mask()
hp.write_map(os.path.join(self.lib_dir, "fmask.fits.gz"),
fmask)
mpi.barrier()
utils.hash_check(
pk.load(open(os.path.join(lib_dir, "filt_hash.pk"), 'rb')),
self.hashdict())
def __init__(self,
lib_dir,
lmax,
nside,
cl,
transf,
ninv,
marge_maps_t=(),
marge_monopole=False,
marge_dipole=False,
pcf='default',
rescal_cl='default',
chain_descr=None,
transf_p=None):
"""Instance for joint temperature-polarization filtering
Args:
lib_dir: a few quantities might get cached there
lmax: CMB filtering performed up to multipole lmax
nside: healpy resolution of the input maps
cl: fiducial CMB spectra used to filter the data (dict with 'tt', 'te', 'ee', 'bb' keys)
transf: CMB transfer function in temperature
ninv: list of lists with mask paths and / or inverse pixel noise levels.
TT, (QQ + UU) / 2 if len(ninv) == 2 or TT, QQ, QU UU if == 4
e.g. [[iNevT,mask1,mask2,..],[iNevP,mask1,mask2...]]
marge_maps_t: maps to project out in the filtering (T-part)
marge_monopole: marginalizes out the T monopole if set
marge_dipole: marginalizes out the T dipole if set
chain_descr: preconditioner mulitgrid chain description (if different from default)
transf_p: polarization transfer function (if different from temperature)
"""
assert (lmax >= 1024)
assert (nside >= 512)
assert len(
ninv) == 2 or len(ninv) == 4 # TT, (QQ + UU)/2 or TT,QQ,QU,UU
if rescal_cl == 'default':
rescal_cl = {
a: np.sqrt(
np.arange(lmax + 1, dtype=float) *
np.arange(1, lmax + 2, dtype=float) / 2. / np.pi)
for a in ['t', 'e', 'b']
}
elif rescal_cl is None:
rescal_cl = {
a: np.ones(lmax + 1, dtype=float)
for a in ['t', 'e', 'b']
}
elif rescal_cl == 'tonly':
rescal_cl = {a: np.ones(lmax + 1, dtype=float) for a in ['e', 'b']}
rescal_cl['t'] = np.sqrt(
np.arange(lmax + 1, dtype=float) *
np.arange(1, lmax + 2, dtype=float) / 2. / np.pi)
else:
assert 0
for k in rescal_cl.keys():
rescal_cl[k] /= np.mean(
rescal_cl[k]
) # in order not mess around with the TEB relative weights of the spectra
dl = {
k: rescal_cl[k[0]] * rescal_cl[k[1]] * cl[k][:lmax + 1]
for k in cl.keys()
} # rescaled cls (Dls by default)
if transf_p is None:
transf_p = transf
transf_dls = {
a: transf_p[:lmax + 1] * utils.cli(rescal_cl[a])
for a in ['e', 'b']
}
transf_dls['t'] = transf[:lmax + 1] * utils.cli(rescal_cl['t'])
self.lmax = lmax
self.nside = nside
self.cl = cl
self.transf_t = transf
self.transf_p = transf_p
self.ninv = ninv
self.marge_maps_t = marge_maps_t
self.marge_maps_p = []
self.lib_dir = lib_dir
self.rescal_cl = rescal_cl
if chain_descr is None:
pcf = lib_dir + "/dense_tp.pk" if pcf == 'default' else None
chain_descr = [[
3, ["split(dense(" + pcf + "), 64, diag_cl)"], 256, 128, 3,
0.0, cd_solve.tr_cg,
cd_solve.cache_mem()
],
[
2, ["split(stage(3), 256, diag_cl)"], 512, 256,
3, 0.0, cd_solve.tr_cg,
cd_solve.cache_mem()
],
[
1, ["split(stage(2), 512, diag_cl)"], 1024,
512, 3, 0.0, cd_solve.tr_cg,
cd_solve.cache_mem()
],
[
0, ["split(stage(1), 1024, diag_cl)"], lmax,
nside, np.inf, 1.0e-5, cd_solve.tr_cg,
cd_solve.cache_mem()
]]
n_inv_filt = util.jit(opfilt_tp.alm_filter_ninv,
ninv,
transf_dls['t'],
b_transf_e=transf_dls['e'],
b_transf_b=transf_dls['b'],
marge_maps_t=marge_maps_t,
marge_monopole=marge_monopole,
marge_dipole=marge_dipole)
self.chain = util.jit(multigrid.multigrid_chain, opfilt_tp,
chain_descr, dl, n_inv_filt)
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(os.path.join(lib_dir, "filt_hash.pk")):
pk.dump(self.hashdict(),
open(os.path.join(lib_dir, "filt_hash.pk"), 'wb'),
protocol=2)
if not os.path.exists(os.path.join(lib_dir, "fal.pk")):
pk.dump(self._calc_fal(),
open(os.path.join(lib_dir, "fal.pk"), 'wb'),
protocol=2)
if not os.path.exists(os.path.join(self.lib_dir, "fmask.fits.gz")):
fmask = self.calc_mask()
hp.write_map(os.path.join(self.lib_dir, "fmask.fits.gz"),
fmask)
mpi.barrier()
utils.hash_check(
pk.load(open(os.path.join(lib_dir, "filt_hash.pk"), 'rb')),
self.hashdict())
def get_n1(self, kA, k_ind, cl_kind, ftlA, felA, fblA, Lmax, kB=None, ftlB=None, felB=None, fblB=None,
clttfid=None, cltefid=None, cleefid=None, n1_flat=lambda ell: np.ones(len(ell), dtype=float),
recache=False, remove_only=False, sglLmode=True):
r"""Calls a N1 bias
Args:
kA: qe_key of QE spectrum first leg
k_ind: anisotropy source key ('p', for standard lensing N1)
cl_kind: spectrum of anisotropy source ('p', for standard lensing N1)
ftlA: first leg T-filtering isotropic approximation
(typically :math:`\frac{1}{C_\ell^{TT} + N_\ell^{TT}}`)
felA: first leg E-filtering isotropic approximation
(typically :math:`\frac{1}{C_\ell^{EE} + N_\ell^{EE}}`)
fblA: first leg B-filtering isotropic approximation
(typically :math:`\frac{1}{C_\ell^{BB} + N_\ell^{BB}}`)
Lmax: maximum multipole of output N1
kB(optional): qe_key of QE spectrum second leg (if different from the first)
ftlB(optional): second leg T-filtering isotropic approximation (if different from the first)
felB(optional): second leg E-filtering isotropic approximation (if different from the first)
fblB(optional): second leg B-filtering isotropic approximation (if different from the first)
clttfid(optional): CMB TT spectrum used in QE weights (if different from instance cltt for map-level CMB spectrum)
cltefid(optional): CMB TE spectrum used in QE weights (if different from instance clte for map-level CMB spectrum)
cleefid(optional): CMB EE spectrum used in QE weights (if different from instance clee for map-level CMB spectrum)
n1_flat(optional): function used to flatten the discretized output before returning splined entire array
Returns:
N1 bias in the form of a numpy array of size Lmax + 1
Note:
This can be called with MPI using a number of processes; in this case the calculations for each multipole will be distributed among these.
"""
if kB is None: kB = kA
# FIXME:
if kA[0] == 's' or kB[0] == 's':
assert kA[0] == kB[0], 'point source implented following DH gradient convention, you wd probably need to pick a sign there'
if ftlB is None: ftlB = ftlA
if felB is None: felB = felA
if fblB is None: fblB = fblA
clttfid = self.cltt if clttfid is None else clttfid
cltefid = self.clte if cltefid is None else cltefid
cleefid = self.clee if cleefid is None else cleefid
if kA in estimator_keys and kB in estimator_keys:
if kA < kB:
return self.get_n1(kB, k_ind, cl_kind, ftlB, felB, fblB, Lmax, ftlB=ftlA, felB=felA, fblB=fblA, kB=kA,
clttfid=clttfid, cltefid=cltefid, cleefid=cleefid, n1_flat=n1_flat, sglLmode=sglLmode)
idx = 'splined_kA' + kA + '_kB' + kB + '_ind' + k_ind
idx += '_clpp' + clhash(cl_kind)
idx += '_ftlA' + clhash(ftlA)
idx += '_felA' + clhash(felA)
idx += '_fblA' + clhash(fblA)
idx += '_ftlB' + clhash(ftlB)
idx += '_felB' + clhash(felB)
idx += '_fblB' + clhash(fblB)
idx += '_clttfid' + clhash(clttfid)
idx += '_cltefid' + clhash(cltefid)
idx += '_cleefid' + clhash(cleefid)
idx += '_Lmax%s' % Lmax
ret = self.npdb.get(idx)
if ret is not None:
if not recache and not remove_only:
return ret
else:
self.npdb.remove(idx)
if remove_only:
return np.zeros_like(ret)
ret = None
if ret is None:
Ls = np.unique(np.concatenate([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], np.arange(1, Lmax + 1)[::20], [Lmax]]))
if sglLmode:
n1L = np.zeros(len(Ls), dtype=float)
for i, L in enumerate(Ls[mpi.rank::mpi.size]):
print("n1: doing L %s kA %s kB %s kind %s" % (L, kA, kB, k_ind))
n1L[i] = (self._get_n1_L(L, kA, kB, k_ind, cl_kind, ftlA, felA, fblA, ftlB, felB, fblB, clttfid, cltefid, cleefid, remove_only=remove_only))
if mpi.size > 1:
mpi.barrier()
for i, L in enumerate(Ls): # reoading cached n1L's
n1L[i] = (self._get_n1_L(L, kA, kB, k_ind, cl_kind, ftlA, felA, fblA, ftlB, felB, fblB, clttfid,
cltefid, cleefid, remove_only=remove_only))
else: # entire vector from f90 openmp call
lmin_ftlA = np.min([np.where(np.abs(fal) > 0.)[0] for fal in [ftlA, felA, fblA]])
lmin_ftlB = np.min([np.where(np.abs(fal) > 0.)[0] for fal in [ftlB, felB, fblB]])
n1L = n1f.n1(Ls, cl_kind, kA, kB, k_ind, self.cltt, self.clte, self.clee,
clttfid, cltefid, cleefid, ftlA, felA, fblA, ftlB, felB, fblB,
lmin_ftlA, lmin_ftlB, self.dL, self.lps)
ret = np.zeros(Lmax + 1)
ret[1:] = spline(Ls, np.array(n1L) * n1_flat(Ls), s=0., ext='raise', k=3)(np.arange(1, Lmax + 1) * 1.)
ret[1:] *= cli(n1_flat(np.arange(1, Lmax + 1) * 1.))
self.npdb.add(idx, ret)
return ret
return self.npdb.get(idx)
if (kA in estimator_keys_derived) and (kB in estimator_keys_derived):
ret = 0.
for (tk1, cl1) in _get_est_derived(kA, Lmax):
for (tk2, cl2) in _get_est_derived(kB, Lmax):
tret = self.get_n1(tk1, k_ind, cl_kind, ftlA, felA, fblA, Lmax, ftlB=ftlB, felB=felB, fblB=fblB,
clttfid=clttfid, cltefid=cltefid, cleefid=cleefid,
kB=tk2, n1_flat=n1_flat, sglLmode=sglLmode)
tret *= cl1[:Lmax + 1]
tret *= cl2[:Lmax + 1]
ret += tret
return ret
elif (kA in estimator_keys_derived) and (kB in estimator_keys):
ret = 0.
for (tk1, cl1) in _get_est_derived(kA, Lmax):
tret = self.get_n1(tk1, k_ind, cl_kind, ftlA, felA, fblA, Lmax, ftlB=ftlB, felB=felB, fblB=fblB, kB=kB,
clttfid=clttfid, cltefid=cltefid, cleefid=cleefid,
n1_flat=n1_flat, sglLmode=sglLmode)
tret *= cl1[:Lmax + 1]
ret += tret
return ret
elif (kA in estimator_keys) and (kB in estimator_keys_derived):
ret = 0.
for (tk2, cl2) in _get_est_derived(kB, Lmax):
tret = self.get_n1(kA, k_ind, cl_kind, ftlA, felA, fblA, Lmax, ftlB=ftlB, felB=felB, fblB=fblB, kB=tk2,
clttfid=clttfid, cltefid=cltefid, cleefid=cleefid,
n1_flat=n1_flat, sglLmode=sglLmode)
tret *= cl2[:Lmax + 1]
ret += tret
return ret
assert 0
def __init__(self,
lib_dir,
lmax,
nside,
cl,
transf,
ninv,
marge_monopole=True,
marge_dipole=True,
marge_maps=(),
pcf='default',
chain_descr=None):
assert lib_dir is not None and lmax >= 1024 and nside >= 512, (lib_dir,
lmax,
nside)
assert isinstance(ninv, list)
super(cinv_t, self).__init__(lib_dir, lmax)
self.nside = nside
self.cl = cl
self.transf = transf
self.ninv = ninv
self.marge_monopole = marge_monopole
self.marge_dipole = marge_dipole
self.marge_maps = marge_maps
pcf = os.path.join(
lib_dir, "dense.pk"
) if pcf == 'default' else '' # Dense matrices will be cached there.
if chain_descr is None: chain_descr = \
[[3, ["split(dense(" + pcf + "), 64, diag_cl)"], 256, 128, 3, 0.0, cd_solve.tr_cg, cd_solve.cache_mem()],
[2, ["split(stage(3), 256, diag_cl)"], 512, 256, 3, 0.0, cd_solve.tr_cg, cd_solve.cache_mem()],
[1, ["split(stage(2), 512, diag_cl)"], 1024, 512, 3, 0.0, cd_solve.tr_cg, cd_solve.cache_mem()],
[0, ["split(stage(1), 1024, diag_cl)"], lmax, nside, np.inf, 1.0e-5, cd_solve.tr_cg, cd_solve.cache_mem()]]
n_inv_filt = util.jit(opfilt_tt.alm_filter_ninv,
ninv,
transf[0:lmax + 1],
marge_monopole=marge_monopole,
marge_dipole=marge_dipole,
marge_maps=marge_maps)
self.chain = util.jit(multigrid.multigrid_chain, opfilt_tt,
chain_descr, cl, n_inv_filt)
if mpi.rank == 0:
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(os.path.join(lib_dir, "filt_hash.pk")):
pk.dump(self.hashdict(),
open(os.path.join(lib_dir, "filt_hash.pk"), 'wb'),
protocol=2)
if not os.path.exists(os.path.join(self.lib_dir, "ftl.dat")):
np.savetxt(os.path.join(self.lib_dir, "ftl.dat"),
self._calc_ftl())
if not os.path.exists(os.path.join(self.lib_dir, "tal.dat")):
np.savetxt(os.path.join(self.lib_dir, "tal.dat"),
self._calc_tal())
if not os.path.exists(os.path.join(self.lib_dir, "fmask.fits.gz")):
hp.write_map(os.path.join(self.lib_dir, "fmask.fits.gz"),
self._calc_mask())
mpi.barrier()
utils.hash_check(
pk.load(open(os.path.join(lib_dir, "filt_hash.pk"), 'rb')),
self.hashdict())
