def hashdict(self): return {'n_inv': clhash(self.n_inv), 'b_transf': clhash(self.b_transf), 'marge_monopole': self.marge_monopole, 'marge_dipole': self.marge_dipole, 'templates_hash': self.templates_hash, 'marge_uptolmin': self.marge_uptolmin}
def hashdict(self): return { 'ivfs': self.ivfs.hashdict(), 'filt_t': utils.clhash(self.lfilt_t[:self.lmax + 1]), 'filt_e': utils.clhash(self.lfilt_e[:self.lmax + 1]), 'filt_b': utils.clhash(self.lfilt_b[:self.lmax + 1]) }
def hashdict(self): return { 'cltt': clhash(self.cltt), 'clte': clhash(self.clte), 'clee': clhash(self.clee), 'dL': self.dL, 'lps': self.lps }
def hashdict(self): return { 'n_inv': [clhash(n) for n in self.n_inv], 'b_transf': clhash(self.b_transf), 'marge_monopole': self.marge_monopole, 'marge_dipole': self.marge_dipole, 'templates_t_hash': self.templates_t_hash }
def hashdict(self): ret = {'lmaxqe':self.lmax_qe, 'lmax_qlm':self.lmax_qlm} for k in self.cls_weight.keys(): ret['clsweight ' + k] = ut.clhash(self.cls_weight[k]) for k in self.cls_cmb.keys(): ret['clscmb ' + k] = ut.clhash(self.cls_cmb[k]) for k in self.fal.keys(): ret['fal' + k] = ut.clhash(self.fal[k]) return ret
def hashdict(self): return { 'lmax': self.lmax, 'nside': self.nside, 'clee': utils.clhash(self.cl.get('ee', np.array([0.]))), 'cleb': utils.clhash(self.cl.get('eb', np.array([0.]))), 'clbb': utils.clhash(self.cl.get('bb', np.array([0.]))), 'transf': utils.clhash(self.transf), 'ninv': self._ninv_hash() }
def hashdict(self): return { 'lmax': self.lmax, 'nside': self.nside, 'cltt': utils.clhash(self.cl['tt'][:self.lmax + 1]), 'transf': utils.clhash(self.transf[:self.lmax + 1]), 'ninv': self._ninv_hash(), 'marge_monopole': self.marge_monopole, 'marge_dipole': self.marge_dipole, 'marge_maps': self.marge_maps }
def hashdict(self): return { 'sim_lib': self.sim_lib.hashdict(), 'transf': utils.clhash(self.transf), 'cl_len': {k: utils.clhash(self.cl[k]) for k in ['tt', 'ee', 'bb']}, 'ftl': utils.clhash(self.ftl), 'fel': utils.clhash(self.fel), 'fbl': utils.clhash(self.fbl) }
def hashdict(self): return { 'lmax': self.lmax, 'nside': self.nside, 'rescal_cl': utils.clhash(self.rescal_cl), 'cls': {k: utils.clhash(self.cl[k]) for k in self.cl.keys()}, 'transf': utils.clhash(self.transf), 'ninv': self._ninv_hash(), 'marge_maps_t': self.marge_maps_t, 'marge_maps_p': self.marge_maps_p }
def _get_n1_L(self, L, kA, kB, k_ind, cl_kind, ftlA, felA, fblA, ftlB, felB, fblB, clttfid, cltefid, cleefid): if kB is None: kB = kA assert kA in estimator_keys and kB in estimator_keys assert len(cl_kind) > self.lmaxphi if kA in estimator_keys and kB in estimator_keys: if kA < kB: return self._get_n1_L(L, kB, kA, k_ind, cl_kind, ftlA, felA, fblA, ftlB, felB, fblB, clttfid, cltefid, cleefid) else: 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] ]) lmax_ftl = np.max([ len(fal) for fal in [ftlA, felA, fblA, ftlB, felB, fblB] ]) - 1 assert len(clttfid) > lmax_ftl and len( self.cltt) > lmax_ftl assert len(cltefid) > lmax_ftl and len( self.clte) > lmax_ftl assert len(cleefid) > lmax_ftl and len( self.clee) > lmax_ftl idx = str(L) + '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) if self.fldb.get(idx) is None: n1_L = n1f.n1l(L, 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) self.fldb.add(idx, n1_L) return n1_L return self.fldb.get(idx) assert 0
def hashdict(self): return { 'cinv_tp': self.cinv_tp.hashdict(), 'clw': {k: utils.clhash(self.cl[k]) for k in self.cl.keys()}, 'sim_lib': self.sim_lib.hashdict() }
def hashdict(self): return { 'transf': utils.clhash(self.transf), 'nlevt': np.float32(self.nlevt), 'nlevp': np.float32(self.nlevp), 'pix_phas': self.pix_libphas.hashdict() }
def __init__(self, cls_unl, lib_pha): lmax = lib_pha.lmax lmin = 0 fields = _get_fields(cls_unl) Nf = len(fields) if verbose: print("I see %s fields: " % Nf + " ".join(fields)) rmat = np.zeros((lmax + 1, Nf, Nf), dtype=float) str = '' for _i, _t1 in enumerate(fields): for _j, _t2 in enumerate(fields): if _j >= _i: if _t1 + _t2 in cls_unl.keys(): rmat[lmin:, _i, _j] = cls_unl[_t1 + _t2][:lmax + 1] rmat[lmin:, _j, _i] = rmat[lmin:, _i, _j] else: str += " " + _t1 + _t2 if verbose and str != '': print(str + ' set to zero') for ell in range(lmin, lmax + 1): t, v = np.linalg.eigh(rmat[ell, :, :]) assert np.all(t >= 0.), (ell, t, rmat[ell, :, :] ) # Matrix not positive semidefinite rmat[ell, :, :] = np.dot(v, np.dot(np.diag(np.sqrt(t)), v.T)) self._cl_hash = {} for k in cls_unl.keys(): self._cl_hash[k] = utils.clhash(cls_unl[k]) self.rmat = rmat self.lib_pha = lib_pha self.fields = fields
def _ninv_hash(self): ret = [] for ninv_comp in self.ninv: if isinstance(ninv_comp, np.ndarray) and ninv_comp.size > 1: ret.append(utils.clhash(ninv_comp)) else: ret.append(ninv_comp) return [ret]
def hashdict(self): ret = { k: utils.clhash(self.cls_weight[k]) for k in self.cls_weight.keys() } ret['ivfs'] = self.ivfs.hashdict() ret['lmax_qlm'] = self.lmax_qlm return ret
def hashdict(self): return { 'sims_cmb_len': self.sims_cmb_len.hashdict(), 'nside': self.nside, 'cl_transf': clhash(self.cl_transf), 'nlev_t': self.nlev_t, 'nlev_p': self.nlev_p, 'pixphas': self.pix_lib_phas.hashdict() }
def hashdict(self): ret = { 'lmax': self.lmax, 'nside': self.nside, 'rescal_cl': { k: utils.clhash(self.rescal_cl[k]) for k in self.rescal_cl.keys() }, 'cls': {k: utils.clhash(self.cl[k]) for k in self.cl.keys()}, 'transf': utils.clhash(self.transf_t), 'ninv': self._ninv_hash(), 'marge_maps_t': self.marge_maps_t, 'marge_maps_p': self.marge_maps_p } if self.transf_p is not self.transf_t: ret['transf_p'] = utils.clhash(self.transf_p) return ret
def _get_n1_L_jtp(self, L, kA, kB, k_ind, cl_kind, Xp, Yp, Ip, Jp, fAlmat, fBlmat, clttfid, cltefid, cleefid): if kB is None: kB = kA if kA in estimator_keys and kB in estimator_keys: if kA < kB: assert 0, 'fix this' else: X, Y = kA[1:] I, J = kB[1:] FXXp = fAlmat.get(X + Xp, fAlmat.get(Xp + X, None)) if FXXp is None: return 0. FYYp = fAlmat.get(Y + Yp, fAlmat.get(Yp + Y, None)) if FYYp is None: return 0. FIIp = fBlmat.get(I + Ip, fBlmat.get(Ip + I, None)) if FIIp is None: return 0. FJJp = fBlmat.get(J + Jp, fBlmat.get(Jp + J, None)) if FJJp is None: return 0. lmax_ftl = np.max([FXXp.size, FYYp.size, FIIp.size, FJJp.size]) - 1 lmin_ftlA = np.min([np.where(np.abs(fal) > 0.)[0] for fal in [FXXp, FYYp]]) lmin_ftlB = np.min([np.where(np.abs(fal) > 0.)[0] for fal in [FIIp, FJJp]]) assert len(clttfid) > lmax_ftl and len(self.cltt) > lmax_ftl assert len(cltefid) > lmax_ftl and len(self.clte) > lmax_ftl assert len(cleefid) > lmax_ftl and len(self.clee) > lmax_ftl assert (FXXp.size == FYYp.size) and (FIIp.size == FJJp.size) assert len(cl_kind) > self.lmaxphi idx = str(L) + X + Xp + Y + Yp + I + Ip + J + Jp idx += '_clpp' + clhash(cl_kind) idx += '_fXXp' + clhash(FXXp) idx += '_fYYp' + clhash(FYYp) idx += '_fIIp' + clhash(FIIp) idx += '_fJJp' + clhash(FJJp) idx += '_clttfid' + clhash(clttfid) idx += '_cltefid' + clhash(cltefid) idx += '_cleefid' + clhash(cleefid) # n1L_jtp(L, cl_kI, kA, kB, XpIp, YpJp, kI, cltt, clte, clee, clttfid, cltefid, # cleefid, & # fXXp, fYYp, fIIp, fJJp, lminA, lmaxA, lminB, lmaxB, lmaxI, & # lmaxtt, lmaxte, lmaxee, lmaxttfid, lmaxtefid, lmaxeefid, dL, lps, nlps) if self.fldb.get(idx) is None: n1_L = n1f.n1l_jtp(L, cl_kind, kA, kB, Xp, Yp, Ip, Jp, k_ind, self.cltt, self.clte, self.clee, clttfid, cltefid, cleefid, FXXp, FYYp, FIIp, FJJp, lmin_ftlA, lmin_ftlB, self.dL, self.lps) self.fldb.add(idx, n1_L) return n1_L return self.fldb.get(idx) assert 0
def mask_hash(m, dtype=bool): if m is None: return "none" if isinstance(m, list): mh = mask_hash(m[0], dtype=dtype) for m2 in m[1:]: mh += mask_hash(m2, dtype=dtype) return mh if isinstance(m, str): return m.replace('/', '_sl_').replace('.', '_') elif isinstance(m, np.ndarray): return utils.clhash(m, dtype=dtype) elif callable(m): return 'callable' assert 0, 'not implemented'
def hashdict(self): return {'slinv': clhash(self.slinv.flatten())}
def get_responses(qe_key, cls_cmb_dat, cls_cmb_filt, cls_weight, lmin, lmax, lmax_qlm, transf, nlevts_filt, nlevps_filt, joint_TP=False, cacher=cachers.cacher_mem(), source='p'): """Collects estimator responses for a list of filtering noise levels Args: qe_key: QE estimator key cls_cmb_dat: CMB cls of the data maps cls_cmb_filt: CMB cls used for the filtering cls_weight: CMB cls in the QE weights lmin: minimum CMB multipole considered lmax: maximum CMB multipole considered lmax_qlm: QE output lmax transf: CMB transfer function nlevts_filt: list or array of filtering temperature noise levels nlevps_filt: list or array of filtering polarization noise levels joint_TP: uses joint temperature and polarization filtering if set, separate if not cacher: can be used to store results source: QE response anisotropy source (defaults to lensing) Returns: lists of responses (GG, CC, GC CG for spin-weight QE) Note: Results may be stored with the cacher but only the filtering noise levels, QE keys and joint_TP are differentiated in the filename """ resps = [] for i, (nlevt_f, nlevp_f) in utils.enumerate_progress( list(zip(nlevts_filt, nlevps_filt)), 'collecting responses'): fname = 'vmapresps%s_%s_%s' % ('jTP' * joint_TP, qe_key, qe_key) + utils.clhash( np.array([nlevt_f, nlevp_f])) if not cacher.is_cached(fname): cls_filt_i = get_ivf_cls(cls_cmb_dat, cls_cmb_filt, lmin, lmax, nlevt_f, nlevp_f, nlevt_f, nlevp_f, transf, jt_tp=joint_TP)[1] this_resp = qresp.get_response(qe_key, lmax, source, cls_weight, cls_cmb_dat, cls_filt_i, lmax_qlm=lmax_qlm) cacher.cache(fname, this_resp) resps.append(cacher.load(fname)) return resps
def get_n1_jtp(self, kA, k_ind, cl_kind, fAlmat, Lmax, kB=None, fBlmat=None, clttfid=None, cltefid=None, cleefid=None, n1_flat=lambda ell: np.ones(len(ell), dtype=float)): 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 fBlmat is None: fBlmat = fAlmat 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_jtp(kB, k_ind, cl_kind, fBlmat, Lmax, fBlmat=fAlmat, kB=kA, clttfid=clttfid, cltefid=cltefid, cleefid=cleefid, n1_flat=n1_flat) X, Y = kA[1:] I, J = kB[1:] assert np.all(i in ['t', 'e', 'b'] for i in [X, Y, I, J]), [X, Y, I, J] ret = 0. for Xp in ['t', 'e', 'b']: FXXp = fAlmat.get(X + Xp, fAlmat.get(Xp + X, [0.])) if np.any(FXXp): for Yp in ['t', 'e', 'b']: FYYp = fAlmat.get(Y + Yp, fAlmat.get(Yp + Y, [0.])) if np.any(FYYp): for Ip in ['t', 'e', 'b']: FIIp = fBlmat.get(I + Ip, fBlmat.get(Ip + I, [0.])) if np.any(FIIp): for Jp in ['t', 'e', 'b']: FJJp = fBlmat.get(J + Jp, fBlmat.get(Jp + J, [0.])) if np.any(FJJp): idx = 'splined_' + X + Xp + Y + Yp + I + Ip + J + Jp idx += '_clpp' + clhash(cl_kind) idx += '_fXXp' + clhash(FXXp) idx += '_fYYp' + clhash(FYYp) idx += '_fIIp' + clhash(FIIp) idx += '_fJJp' + clhash(FJJp) idx += '_clttfid' + clhash(clttfid) idx += '_cltefid' + clhash(cltefid) idx += '_cleefid' + clhash(cleefid) idx += '_Lmax%s' % Lmax if self.npdb.get(idx) is None: Ls = np.unique(np.concatenate([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], np.arange(1, Lmax + 1)[::20], [Lmax]])) n1L = np.zeros(len(Ls), dtype=float) for i, L in enumerate(Ls): print("n1: doing L %s kA %s kB %s kind %s " % (L, kA, kB, k_ind) + Xp + Yp + Ip + Jp) n1L[i] = (self._get_n1_L_jtp(L, kA, kB, k_ind, cl_kind, Xp, Yp, Ip, Jp, fAlmat, fBlmat, clttfid, cltefid, cleefid)) 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) ret = ret + self.npdb.get(idx) return ret if (kA in estimator_keys_derived) or (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_jtp(tk1, k_ind, cl_kind, fAlmat, Lmax, kB=tk2, fBlmat=fBlmat, clttfid=clttfid, cltefid=cltefid, cleefid=cleefid, n1_flat=n1_flat) ret = ret + tret * cl1[:Lmax + 1] * cl2[:Lmax + 1] return ret assert 0
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 get_nhls(qe_key1, qe_key2, cls_cmb_dat, cls_cmb_filt, cls_weight, lmin, lmax, lmax_qlm, transf, nlevts_filt, nlevts_map, nlevps_filt, nlevps_map, joint_TP=False, cacher=cachers.cacher_mem()): """Collects unnormalized estimator noise levels for a list of filtering noise levels and data map noise levels Args: qe_key1: first QE estimator key qe_key2: second QE estimator key cls_cmb_dat: CMB cls of the data maps cls_cmb_filt: CMB cls used for the filtering cls_weight: CMB cls in the QE weights lmin: minimum CMB multipole considered lmax: maximum CMB multipole considered lmax_qlm: QE output lmax transf: CMB transfer function nlevts_filt: list or array of filtering temperature noise levels nlevts_map: list or array of data map temperature noise levels nlevps_filt: list or array of filtering polarization noise levels nlevps_map: list or array of data maptemperature noise levels joint_TP: uses joint temperature and polarization filtering if set, separate if not cacher: can be used to store results Returns: lists of reconstruction noise levels (GG, CC, GC CG for spin-weight QE) Note: Results may be stored with the cacher but only the filtering and data noise levels, QE keys and joint_TP are differentiated in the filename """ Nhls = [] for i, (nlevt_f, nlevt_m, nlevp_f, nlevp_m) in utils.enumerate_progress( list(zip(nlevts_filt, nlevts_map, nlevps_filt, nlevps_map)), 'collecting nhls'): fname = 'vmapnhl%s_%s_%s' % ( 'jTP' * joint_TP, qe_key1, qe_key2) + utils.clhash( np.array([nlevt_f, nlevt_m, nlevp_f, nlevp_m])) if not cacher.is_cached(fname): ivf_cls = get_ivf_cls(cls_cmb_dat, cls_cmb_filt, lmin, lmax, nlevt_f, nlevp_f, nlevt_m, nlevp_m, transf, jt_tp=joint_TP)[0] this_nhl = nhl.get_nhl(qe_key1, qe_key2, cls_weight, ivf_cls, lmax, lmax, lmax_out=lmax_qlm) cacher.cache(fname, this_nhl) Nhls.append(cacher.load(fname)) return Nhls
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), sglLmode=True): """ """ 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, ftlA, felA, fblA, Lmax, ftlB=ftlB, felB=felB, fblB=fblB, kB=kA, clttfid=clttfid, cltefid=cltefid, cleefid=cleefid, n1_flat=n1_flat) 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 if self.npdb.get(idx) is None: Ls = np.unique( np.concatenate([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], np.arange(1, Lmax + 1)[::10], [Lmax]])) if sglLmode: n1L = np.zeros(len(Ls), dtype=float) for i, L in enumerate(Ls): 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)) 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 self.npdb.get(idx) assert np.all([np.all(ftlA == ftlB), np.all(felA == felB), np.all(fblA == fblB)]), \ 'check the est. breakdown is OK for non-identical legs' 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) 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) 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) tret *= cl2[:Lmax + 1] ret += tret return ret assert 0
def hashdict(self): return { 'clkk_inv': clhash(self.clkk_inv), 'n_inv_filt': self.n_inv_filt.hashdict() }
def __init__(self, n_inv, b_transf, b_transf_e=None, b_transf_b=None, marge_monopole=False, marge_dipole=False, marge_maps_t=(), marge_maps_p=()): # n_inv = [util.load_map(n[:]) for n in n_inv] self.n_inv = [] for i, tn in enumerate(n_inv): if isinstance(tn, list): n_inv_prod = read_map(tn[0][:]) if len(tn) > 1: for n in tn[1:]: n_inv_prod = n_inv_prod * read_map(n[:]) self.n_inv.append(n_inv_prod) # assert (np.std(self.n_inv[i][np.where(self.n_inv[i][:] != 0.0)]) / np.average( # self.n_inv[i][np.where(self.n_inv[i][:] != 0.0)]) < 1.e-7) else: self.n_inv.append(read_map(n_inv[i])) n_inv = self.n_inv npix = len(n_inv[0]) nside = hp.npix2nside(npix) for n in n_inv[1:]: assert (len(n) == npix) templates_t = [] templates_t_hash = [] for tmap in [read_map(m) for m in marge_maps_t]: assert (npix == len(tmap)) templates_t.append(template_removal.template_map(tmap)) templates_t_hash.append(clhash(tmap)) if marge_monopole: templates_t.append(template_removal.template_monopole()) if marge_dipole: templates_t.append(template_removal.template_dipole()) if len(templates_t) != 0: nmodes = np.sum([t.nmodes for t in templates_t]) modes_idx_t = np.concatenate( ([t.nmodes * [int(im)] for im, t in enumerate(templates_t)])) modes_idx_i = np.concatenate( ([range(0, t.nmodes) for t in templates_t])) Pt_Nn1_P = np.zeros((nmodes, nmodes)) for ir in range(0, nmodes): tmap = np.copy(n_inv[0]) templates_t[modes_idx_t[ir]].apply_mode( tmap, int(modes_idx_i[ir])) ic = 0 for tc in templates_t[0:modes_idx_t[ir] + 1]: Pt_Nn1_P[ir, ic:(ic + tc.nmodes)] = tc.dot(tmap) Pt_Nn1_P[ic:(ic + tc.nmodes), ir] = Pt_Nn1_P[ir, ic:(ic + tc.nmodes)] ic += tc.nmodes self.Pt_Nn1_P_inv = np.linalg.inv(Pt_Nn1_P) self.n_inv = n_inv self.b_transf_t = b_transf self.b_transf_e = b_transf_e if b_transf_e is not None else b_transf self.b_transf_b = b_transf_b if b_transf_b is not None else b_transf assert len(self.b_transf_t) == len(self.b_transf_e) and len( self.b_transf_t) == len(self.b_transf_e) self.b_transf = (self.b_transf_t + self.b_transf_e + self.b_transf_t) / 3. self.marge_monopole = marge_monopole self.marge_dipole = marge_dipole self.templates_t = templates_t self.templates_t_hash = templates_t_hash assert len(marge_maps_p) == 0 self.templates_p = [] self.npix = npix self.nside = nside
def hashdict(self): return {'n_inv': [clhash(n) for n in self.n_inv], 'b_transf': clhash(self.b_transf), 'templates_p':self.templates_p}
def hashdict(self): return { 'ivfs': self.ivfs.hashdict(), 'nside': self.nside, 'clte': ut.clhash(self.clte) }
def hashdict(self): return { 'sims_cmb_len': self.sims_cmb_len.hashdict(), 'nside': self.nside, 'cl_transf': clhash(self.cl_transf) }