def __init__(self, lib_dir, cltt, clte, clee, lmaxphi=2500, dL=10, lps=None):
if lps is None:
lps = [1]
for l in range(2, 111, 10):
lps.append(l)
for l in range(lps[-1] + 30, 580, 30):
lps.append(l)
for l in range(lps[-1] + 100, lmaxphi // 2, 100):
lps.append(l)
for l in range(lps[-1] + 300, lmaxphi, 300):
lps.append(l)
if lps[-1] != lmaxphi:
lps.append(lmaxphi)
lps = np.array(lps)
self.dL = dL
self.lps = lps
self.cltt = cltt
self.clte = clte
self.clee = clee
self.lmaxphi = lps[-1]
self.n1 = {}
if not os.path.exists(lib_dir):
os.makedirs(lib_dir)
if not os.path.exists(os.path.join(lib_dir, 'n1_hash.pk')):
pk.dump(self.hashdict(), open(os.path.join(lib_dir, 'n1_hash.pk'), 'wb'), protocol=2)
hash_check(self.hashdict(), pk.load(open(os.path.join(lib_dir, 'n1_hash.pk'), 'rb')))
self.npdb = sql.npdb(os.path.join(lib_dir, 'npdb.db'))
self.fldb = sql.fldb(os.path.join(lib_dir, 'fldb.db'))
self.lib_dir = lib_dir
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, 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, 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, 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, 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, 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_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,
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
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_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())
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())
