def __call__(self, get_alm, nside): """Returns the spin-weighted real-space map of the estimator. We first build X_lm in the wanted _{si}X_lm _{so}Y_lm and then convert this alm2map_spin conventions. """ lmax = self.get_lmax() glm = np.zeros(hp.Alm.getsize(lmax), dtype=complex) clm = np.zeros(hp.Alm.getsize(lmax), dtype=complex) # X_{lm} is here glm + i clm for i, (si, cl) in enumerate(zip(self.spins_in, self.cls)): assert si in [0, -2, 2], str(si) + ' input spin not implemented' gclm = [get_alm('e'), get_alm('b') ] if abs(si) == 2 else [-get_alm('t'), 0.] assert len(gclm) == 2 sgn_g = -(-1)**si if si < 0 else -1 sgn_c = (-1)**si if si < 0 else -1 glm += hp.almxfl(ut.alm_copy(gclm[0], lmax), sgn_g * cl) if np.any(gclm[1]): clm += hp.almxfl(ut.alm_copy(gclm[1], lmax), sgn_c * cl) glm *= -1 if self.spin_ou > 0: clm *= -1 Red, Imd = uspin.alm2map_spin((glm, clm), nside, abs(self.spin_ou), lmax) if self.spin_ou < 0 and self.spin_ou % 2 == 1: Red *= -1 if self.spin_ou < 0 and self.spin_ou % 2 == 0: Imd *= -1 return Red + 1j * Imd
def get_sim_qlm(self, k, idx, lmax=None): """Returns a QE estimate, by computing and caching it if not done previously. Args: k: quadratic estimator key idx: simulation index lmax: optionally reduces the lmax of the output healpy array. """ assert k in self.keys, (k, self.keys) if lmax is None: lmax = self.get_lmax_qlm(k) assert lmax <= self.get_lmax_qlm(k) if k in ['p_tp', 'x_tp', 'f_tp', 's_tp']: return self.get_sim_qlm('%stt' % k[0], idx, lmax=lmax) + self.get_sim_qlm( '%s_p' % k[0], idx, lmax=lmax) if k in ['p_te', 'p_tb', 'p_eb', 'x_te', 'x_tb', 'x_eb']: return self.get_sim_qlm(k[0] + k[2] + k[3], idx, lmax=lmax) + self.get_sim_qlm( k[0] + k[3] + k[2], idx, lmax=lmax) if '_bh_' in k: # Bias-hardening assert self.resplib is not None, 'resplib arg necessary for this' kQE, ksource = k.split('_bh_') assert len(ksource) == 1 and ksource + kQE[1:] in self.keys, ( ksource, kQE) assert self.get_lmax_qlm(kQE) == self.get_lmax_qlm( ksource + kQE[1:]), 'fix this (easy)' lmax = self.get_lmax_qlm(kQE) wL = self.resplib.get_response(kQE, ksource) * ut.cli( self.resplib.get_response(ksource + kQE[1:], ksource)) ret = self.get_sim_qlm(kQE, idx, lmax=lmax) return ret - hp.almxfl( self.get_sim_qlm(ksource + kQE[1:], idx, lmax=lmax), wL) assert k in self.keys_fund, (k, self.keys_fund) fname = os.path.join( self.lib_dir, 'sim_%s_%04d.fits' % (k, idx) if idx != -1 else 'dat_%s.fits' % k) if not os.path.exists(fname): if k in ['ptt', 'xtt']: self._build_sim_Tgclm(idx) elif k in ['p_p', 'x_p']: self._build_sim_Pgclm(idx) elif k in ['p', 'x']: self._build_sim_MVgclm(idx) elif k in ['f']: self._build_sim_f(idx) elif k in ['stt']: self._build_sim_stt(idx) elif k in ['ftt']: self._build_sim_ftt(idx) elif k in ['f_p']: self._build_sim_f_p(idx) elif k in ['ntt']: self._build_sim_ntt(idx) elif k in ['a_p']: self._build_sim_a_p(idx) elif k in [ 'ptt', 'pte', 'pet', 'ptb', 'pbt', 'pee', 'peb', 'pbe', 'pbb', 'xtt', 'xte', 'xet', 'xtb', 'xbt', 'xee', 'xeb', 'xbe', 'xbb' ]: self._build_sim_xfiltMVgclm(idx, k) else: assert 0, k return ut.alm_copy(hp.read_alm(fname), lmax=lmax)
def get_sim_qlm_mf(self, k, mc_sims, lmax=None): """Returns a QE mean-field estimate, by averaging QE estimates from a set simulations (caches the result). Args: k: quadratic estimator key mc_sims: simulation indices to use for the estimate. lmax: optionally reduces the lmax of the output healpy array. """ if lmax is None: lmax = self.get_lmax_qlm(k) assert lmax <= self.get_lmax_qlm(k) if k in ['p_tp', 'x_tp']: return (self.get_sim_qlm_mf('%stt' % k[0], mc_sims, lmax=lmax) + self.get_sim_qlm_mf('%s_p' % k[0], mc_sims, lmax=lmax)) if k in ['p_te', 'p_tb', 'p_eb', 'x_te', 'x_tb', 'x_eb']: return self.get_sim_qlm_mf(k[0] + k[2] + k[3], mc_sims, lmax=lmax) \ + self.get_sim_qlm_mf(k[0] + k[3] + k[2], mc_sims, lmax=lmax) if '_bh_' in k: # Bias-hardening assert self.resplib is not None, 'resplib arg necessary for this' kQE, ksource = k.split('_bh_') assert len(ksource) == 1 and ksource + kQE[1:] in self.keys, ( ksource, kQE) assert self.get_lmax_qlm(kQE) == self.get_lmax_qlm( ksource + kQE[1:]), 'fix this (easy)' lmax = self.get_lmax_qlm(kQE) wL = self.resplib.get_response(kQE, ksource) * ut.cli( self.resplib.get_response(ksource + kQE[1:], ksource)) ret = self.get_sim_qlm_mf(kQE, mc_sims, lmax=lmax) return ret - hp.almxfl( self.get_sim_qlm_mf(ksource + kQE[1:], mc_sims, lmax=lmax), wL) assert k in self.keys_fund, (k, self.keys_fund) fname = os.path.join(self.lib_dir, 'simMF_k1%s_%s.fits' % (k, ut.mchash(mc_sims))) if not os.path.exists(fname): this_mcs = np.unique(mc_sims) MF = np.zeros(hp.Alm.getsize(lmax), dtype=complex) if len(this_mcs) == 0: return MF for i, idx in ut.enumerate_progress(this_mcs, label='calculating %s MF' % k): MF += self.get_sim_qlm(k, idx, lmax=lmax) MF /= len(this_mcs) _write_alm(fname, MF) print("Cached ", fname) return ut.alm_copy(hp.read_alm(fname), lmax=lmax)
def get_sim_bmliklm(self, idx): return hp.almxfl( utils.alm_copy(self.ivfs.get_sim_bmliklm(idx), lmax=self.lmax), self.lfilt_b)
def almxfm(alm, fm, lmax): ret = utils.alm_copy(alm, lmax=lmax) for m in range(lmax + 1): ret[hp.Alm.getidx(lmax, np.arange(m, lmax + 1, dtype=int), m)] *= fm[m] return ret