def fisher_single(par,v) : # v -> seen pixels nb=len(par.bins)-1 npix=hp.nside2npix(par.nside) npix_seen=len(par.ip_seen) lmax=3*par.nside-1 larr=np.arange(lmax+1) fisher=np.zeros([nb,nb]) pixsize=4*np.pi/hp.nside2npix(par.nside) v_map=np.zeros(npix); v_map[par.ip_seen]=v vcm1=invert_covar(par,v_map) v_lm=hp.map2alm(v_map,iter=0) vcm1_lm=hp.map2alm(vcm1,iter=0) for iba in np.arange(nb) : # print " Row %d"%iba transfer=np.zeros(lmax+1); transfer[par.bins[iba]:par.bins[iba+1]]=1. v_map2=hp.alm2map(hp.almxfl(v_lm,transfer),par.nside,verbose=False)/pixsize #Q_a * v v_map2cm1=invert_covar(par,v_map2) #C^-1 * Q_a * v va_lm=hp.map2alm(v_map2cm1,iter=0) cl_vcm1_va=(2*larr+1)*hp.alm2cl(vcm1_lm,alms2=va_lm) for ibb in np.arange(nb-iba)+iba : fisher[iba,ibb]=np.sum(cl_vcm1_va[par.bins[ibb]:par.bins[ibb+1]])/pixsize**2 if iba!=ibb : fisher[ibb,iba]=fisher[iba,ibb] return fisher
def estimate_alm(sky_map, lmax, binary_mask=None, pol=False): sky_map_masked = mask_map(sky_map, binary_mask, pol=pol) if pol: alm = hp.map2alm((sky_map_masked[0].filled(), sky_map_masked[1].filled(), sky_map_masked[2].filled()), lmax=lmax) else: alm = hp.map2alm(sky_map_masked.filled(), lmax=lmax) return alm
def map2vlm( m, lmax, iter=0 ): alm_re = hp.map2alm( m.real.copy(), lmax=lmax, iter=iter, regression=False ) alm_im = hp.map2alm( m.imag.copy(), lmax=lmax, iter=iter, regression=False ) ret = np.zeros( (lmax+1)**2, dtype=np.complex ) for l in xrange(0, lmax+1): ms = np.arange(1,l+1) ret[l*l+l] = alm_re[l] + 1.j * alm_im[l] ret[l*l+l+ms] = alm_re[ms * (2*lmax+1-ms)/2 + l] + 1.j * alm_im[ms * (2*lmax+1-ms)/2 + l] ret[l*l+l-ms] = (-1)**ms * ( np.conj( alm_re[ms * (2*lmax+1-ms)/2 + l] ) + 1.j * np.conj( alm_im[ms * (2*lmax+1-ms)/2 + l] ) ) return ret
def sphtrans_real_pol(hpmaps, lmax=None, lside=None): """Spherical Harmonic transform of polarisation functions on the sky. Accepts real T, Q, U and optionally V like maps, and returns :math:`a^T_{lm}`, :math:`a^E_{lm}`, :math:`a^B_{lm}` and :math:`a^V_{lm}`. Parameters ---------- hpmaps : np.ndarray[npol, npix] An array of Healpix maps, assumed to be T, Q, U and potentially V. lmax : scalar, optional The maximum l to calculate. If `None` (default), calculate up to 3*nside - 1. Returns ------- alms[npol, lmax+1, lmax+1] : np.ndarray A 3d array of alms, packed as alm[pol, l, m]. Notes ----- This only includes m >= 0. As these are the transforms of a real field: .. math:: a_{l -m} = (-1)^m a_{lm}^* """ if lmax is None: lmax = 3*healpy.npix2nside(hpmaps[0].size) - 1 if lside is None or lside < lmax: lside = lmax npol = len(hpmaps) alms = np.zeros([npol, lside+1, lside+1], dtype=np.complex128) hpmaps = np.ascontiguousarray(hpmaps) tlms = healpy.map2alm([hpmap for hpmap in hpmaps[:3]], lmax=lmax, use_weights=_weight, iter=_iter) for i in range(3): alms[i][np.triu_indices(lmax+1)] = tlms[i] # Transform Stokes-V if npol == 4: alms[3][np.triu_indices(lmax+1)] = healpy.map2alm(np.ascontiguousarray(hpmaps[3]), lmax=lmax, use_weights=_weight, iter=_iter) return alms.transpose((0, 2, 1))
def _interpolate_jones_freq(J_in, freqs, multiway=True, interp_type='spline'): """ A scheme to interpolate the spherical harmonic components of jones matrix elements. Does not seem to work well, and is unused. """ nfreq_in = len(freqs) if multiway == True: J_flat = np.zeros((nfreq_in, npix, 8), dtype='float64') for i in range(nfreq_in): J_flat[i] = irf.flatten_jones(J_in[i]) J_in = J_flat lmax = 3 * nside -1 nlm = hp.Alm.getsize(lmax) Jlm_in = np.zeros(nfreq_in, nlm, 8) for i in range(nfreq_in): sht = lambda m: hp.map2alm(m, lmax=lmax) Jlm_in[i,:,:] = (np.asarray(map(sht, J_in.T))).T Jlm_out = np.zeros(p.nfreq, nlm, 8) for lm in range(nlm): for j in range(8): Jlmj_re = np.real(Jlm_in[:,lm,j]) Jlmj_im = np.imag(Jlm_in[:,lm,j]) a = interpolate_pixel(Jlmj_re, freqs, p.nu_axis, interp_type=p.interp_type) # note! interpolate_pixel function no longer exists b = interpolate_pixel(Jlmj_im, freqs, p.nu_axis, interp_type=p.interp_type) Jlm_out[:, lm, j] = a + 1j*b
def get_Tlm(filename='test_tlm.npy', Imap=None, mask=None, add_beam=None,div_beam=None, healpy_format=False, lmax=100, recalc=False, filtermap=False, l0=None, save=False): """computes and saves 2d alms from a given map and mask, corrected for sqrt(fsky), beams added or divided by choice. """ if not recalc and os.path.exists(data_path + filename): Tlm2d = np.load(data_path + filename) return Tlm2d fsky = mask.sum() / len(mask) Tlm = hp.map2alm(Imap * mask, lmax=lmax) / np.sqrt(fsky) if add_beam is not None: hp.sphtfunc.almxfl(Tlm, add_beam, inplace=True) if div_beam is not None: hp.sphtfunc.almxfl(Tlm, 1./div_beam, inplace=True) if not healpy_format: ls, ms = hp.sphtfunc.Alm.getlm(lmax, np.arange(len(Tlm))) Tlm = make2d_alm_square(Tlm, lmax, ls, ms) if save: np.save(data_path + filename, Tlm) return Tlm
def taylor_interpol_iter(m, pos, order=3, verbose=False, lmax=None): """Given a healpix map m[npix], and a set of positions pos[{theta,phi},...], evaluate the values at those positions using harmonic Taylor interpolation to the given order (3 by default). Successively yields values for each cumulative order up to the specified one. If verbose is specified, it will print progress information to stderr.""" nside = hp.npix2nside(m.size) if lmax is None: lmax = 3*nside # Find the healpix pixel centers closest to pos, # and our deviation from these pixel centers. ipos = hp.ang2pix(nside, pos[0], pos[1]) pos0 = np.array(hp.pix2ang(nside, ipos)) dpos = pos[:2]-pos0 # Take wrapping into account bad = dpos[1]>np.pi dpos[1,bad] = dpos[1,bad]-2*np.pi bad = dpos[1]<-np.pi dpos[1,bad] = dpos[1,bad]+2*np.pi # Since healpix' dphi actually returns dphi/sintheta, we choose # to expand in terms of dphi*sintheta instead. dpos[1] *= np.sin(pos0[0]) del pos0 # We will now Taylor expand our healpix field to # get approximations for the values at our chosen # locations. The structure of this section is # somewhat complicated by the fact that alm2map_der1 returns # two different derivatives at the same time. derivs = [[m]] res = m[ipos] yield res for o in range(1,order+1): # Compute our derivatives derivs2 = [None for i in range(o+1)] used = [False for i in range(o+1)] # Loop through previous level in steps of two (except last) if verbose: tprint("order %d" % o) for i in range(o): # Each alm2map_der1 provides two derivatives, so avoid # doing double work. if i < o-1 and i % 2 == 1: continue a = hp.map2alm(derivs[i], use_weights=True, lmax=lmax, iter=0) derivs[i] = None dtheta, dphi = hp.alm2map_der1(a, nside, lmax=lmax)[-2:] derivs2[i:i+2] = [dtheta,dphi] del a, dtheta, dphi # Use these to compute the next level for j in range(i,min(i+2,o+1)): if used[j]: continue N = comb(o,j)/factorial(o) res += N * derivs2[j][ipos] * dpos[0]**(o-j) * dpos[1]**j used[j] = True # If we are at the last order, we don't need to waste memory # storing the derivatives any more if o == order: derivs2[j] = None derivs = derivs2 yield res
def test_map2alm_pol_gal_cut(self): tmp = [np.empty(o.size * 2) for o in self.mapiqu] for t, o in zip(tmp, self.mapiqu): t[::2] = o maps = [ self.mapiqu, [o.astype(np.float32) for o in self.mapiqu], [t[::2] for t in tmp], ] for use_weights in [False, True]: for input in maps: gal_cut = 30 nside = hp.get_nside(input) npix = hp.nside2npix(nside) gal_mask = ( np.abs(hp.pix2ang(nside, np.arange(npix), lonlat=True)[1]) < gal_cut ) alm = hp.map2alm( input, iter=10, use_weights=use_weights, gal_cut=gal_cut ) output = hp.alm2map(alm, 32) for i, o in zip(input, output): # Testing requires low tolerances because of the # mask boundary i[gal_mask] = 0 np.testing.assert_allclose(i, o, atol=1e-2)
def getReconstructionsAligned(idShell, Ilm_na, Lgrid, Lmax=7, vmin = 1e-4, nside=128): Ir = np.zeros((hp.nside2npix(nside), np.size(idShell))) for id, Ilm in enumerate(Ilm_na): Ilm = np.ascontiguousarray(Ilm) if id == 0: '''align the first shell with theoretically calculated intensity''' Ith = np.load('first_shell_to_start_alignment.npy') almth = hp.map2alm(Ith, Lmax-1) almr = alignShells(almth, Ilm, Lmax-1, Lgrid) rI = hp.alm2map(almr, nside) neg = np.where(rI < 0) rI[neg] = vmin Ir[:, 0] = rI else: ''' Align the succesive shells with respect to each preceding shell ''' almr = alignShells(almr, Ilm, Lmax-1, Lgrid) rI = hp.alm2map(almr, nside) neg = np.where(rI < 0) rI[neg] = vmin Ir[:, id] = rI return Ir
def VisM( self ) : ''' Use BeamLM and TmapLM to calculate V(m)/vism vism is the FFT of vis return: self.vism = [V(m), V(-m)] # NOT conj self.vism.shape = (2, Npoint, 1, Nv, lmax+1) Nfreq=1 ''' if (self.verbose) : print 'Tmap2Vis.VisM \n' lmax, shape = self.lmax, self.beamlm.shape Np, Nv, Nl = shape[1], shape[2], shape[4] self.vism = np.zeros([2, Np, 1, Nv, Nl], complex) almT = hp.map2alm(self.Tmap, lmax) #-------------------------------------------------- l = np.arange(lmax+1) m = l.copy() # For Tmap ('Alm') idxT = jp.LM2Index('Alm', lmax, l, m, '2D')[0] idxT = jp.Invalid(idxT , 0).astype(int).T # ml #-------------------------------------------------- self.vism[0,:,0,:,:] = (self.beamlm[0] * almT[idxT][None,None,:,:]).sum(-1) self.vism[1,:,0,:,:] = np.conj( (self.beamlm[1] * almT[idxT][None,None,:,:]).sum(-1) ) return self.vism
def sphtrans_real(hpmap, lmax=None, lside=None): """Spherical Harmonic transform of a real map. Parameters ---------- hpmap : np.ndarray A Healpix map. lmax : scalar, optional The maximum l to calculate. If `None` (default), calculate up to 3*nside - 1. Returns ------- alm : np.ndarray A 2d array of alms, packed as alm[l,m]. Notes ----- This only includes m > 0. As this is the transform of a real field: .. math:: a_{l -m} = (-1)^m a_{lm}^* """ if lmax == None: lmax = 3*healpy.npix2nside(hpmap.size) - 1 if lside == None or lside < lmax: lside = lmax alm = np.zeros([lside+1, lside+1], dtype=np.complex128) tlm = healpy.map2alm(np.ascontiguousarray(hpmap), lmax=lmax, use_weights=_weight, iter=_iter) alm[np.triu_indices(lmax+1)] = tlm return alm.T
def rotate_map_to_axis(m, ra, dec, nest=False, method="direct"): """Rotate a sky map to place a given line of sight on the +z axis. Parameters ---------- m : np.ndarray The input HEALPix array. ra : float Right ascension of axis in radians. To specify the axis in geocentric coordinates, supply ra=(lon + gmst), where lon is the geocentric longitude and gmst is the Greenwich mean sidereal time in radians. dec : float Declination of axis in radians. To specify the axis in geocentric coordinates, supply dec=lat, where lat is the geocentric latitude in radians. nest : bool, default=False Indicates whether the input sky map is in nested rather than ring-indexed HEALPix coordinates (default: ring). method : 'direct' or 'fft' Select whether to use spherical harmonic transformation ('fft') or direct coordinate transformation ('direct') Returns ------- m_rotated : np.ndarray The rotated HEALPix array. """ npix = len(m) nside = hp.npix2nside(npix) theta = 0.5 * np.pi - dec phi = ra if method == "fft": if nest: m = hp.reorder(m, n2r=True) alm = hp.map2alm(m) hp.rotate_alm(alm, -phi, -theta, 0.0) ret = hp.alm2map(alm, nside, verbose=False) if nest: ret = hp.reorder(ret, r2n=True) elif method == "direct": R = hp.Rotator(rot=np.asarray([0, theta, -phi]), deg=False, inv=False, eulertype="Y") theta, phi = hp.pix2ang(nside, np.arange(npix), nest=nest) ipix = hp.ang2pix(nside, *R(theta, phi), nest=nest) ret = m[ipix] else: raise ValueError("Unrecognized method: {0}".format(method)) return ret
def harmonic_ud_grade(m, nside_in, nside_out): """ Decompose a map at a resolution nside_in into spherical harmonic components and then resynthesize the map at nside_out. """ lmax = 3 * nside_in - 1 alm = hp.map2alm(m, lmax=lmax) return hp.alm2map(alm, nside_out, lmax=lmax, verbose=False)
def test_rotate_alm(self): almigc = hp.map2alm(self.mapiqu) alms = [almigc[0], almigc[0:2], almigc, np.vstack(almigc)] for i in alms: o = deepcopy(i) hp.rotate_alm(o, 0.1, 0.2, 0.3) hp.rotate_alm(o, -0.3, -0.2, -0.1) np.testing.assert_allclose(i, o, rtol=1e-6)
def A_matrix_func(data): """ cf eq 25 of eriksen 2004 """ Chalf = np.sqrt(data.cl_th[: data.lmax + 1]) * data.beam[: data.lmax + 1] map2 = hp.alm2map(hp.almxfl(real2complex_alm(data.alm), Chalf), data.nside) * data.invvar alm2 = hp.almxfl(hp.map2alm(map2, data.lmax, use_weights=False) * hp.nside2npix(data.nside) / 4.0 / np.pi, Chalf) return data.alm + complex2real_alm(alm2)
def direct(self, input, output): if input.ndim == 1: input = input[:, None] output = output[:, None] for i, o in zip(input.T, output.T): ialm = hp.map2alm(i) alm_smoothed = hp.almxfl(ialm, self.fl) o[...] = hp.alm2map(alm_smoothed, hp.npix2nside(len(i)))# * \
def rs_w1_matrix_func(data, w1): """ cf eq 25 of eriksen 2004 """ Chalf = np.sqrt(data.cl_th[: data.lmax]) * data.beam[: data.lmax] map2 = w1 * np.sqrt(data.invvar) # map2 = hp.alm2map(real2complex_alm(data.alm),data.nside)*np.sqrt(data.invvar) alm2 = hp.almxfl(hp.map2alm(map2, data.lmax, use_weights=False) * hp.nside2npix(data.nside) / 4.0 / np.pi, Chalf) return complex2real_alm(alm2)
def correlation2pt(map1, map2=None, npoints=100): if map2 is None: map2 = map1 alm1 = hp.map2alm(map1) alm2 = hp.map2alm(map2) clcross = hp.alm2cl(alm1, alm2) thetas = np.linspace(0., np.pi, npoints) corr = np.zeros(npoints) for i,theta in enumerate(thetas): for l,cl in enumerate(clcross): lfactor = (2*l + 1.)/(4.*np.pi) * scipy.special.lpmv(0, l, np.cos(theta)) corr[i] += lfactor * cl return thetas, corr
def hires_healpixellize(map_data,theta,phi,nside_interp,nside_synth): map = healpixellize(map_data,theta,phi,nside_interp) lmax = 3*nside_interp-1 # l,m=hp.Alm.getlm(lmax) alm = hp.map2alm(map,lmax=lmax) return hp.alm2map(alm,nside_synth,lmax=lmax)
def test_rotate_alm(self): almigc = hp.map2alm(self.mapiqu) alms = [almigc[0], almigc[0:2], almigc, np.vstack(almigc)] for i in alms: o = deepcopy(i) hp.rotate_alm(o, 0.1, 0.2, 0.3) hp.rotate_alm(o, -0.3, -0.2, -0.1) # FIXME: rtol=1e-6 works here, except on Debian with Python 3.4. np.testing.assert_allclose(i, o, rtol=1e-5)
def TQU_TO_TEB_maps(sky_TQU, lmax): nside = hp.get_nside(sky_TQU) alm_in = hp.map2alm(sky_TQU, lmax, pol=True) sky_TEB = np.empty((3, 12*nside**2)) for i in range(3): sky_TEB[i] = hp.alm2map(alm_in[i], nside, pol=False) return sky_TEB
def BeamLmax( self, verbose=None ) : ''' Decompose BeamMapComplex (with phase) to lm with lmax return: self.beamlmax.shape = (Npointing, Nv, (lmax+1)**2) ''' if (self.verbose) : print 'Tmap2Vis.BeamLmax' if (verbose is None) : verbose = self.verbose lmax = self.lmax l = np.arange(lmax+1) # Negetive mn = np.arange(-l.max(), 0) idxdsn, morder = jp.LM2Index('almds', lmax, l, mn)[:2] idxmn = jp.LM2Index('alm' , lmax, l, -mn)[0] # Positive mp = np.arange(0, l.max()+1) idxdsp = jp.LM2Index('almds', lmax, l, mp)[0] idxmp = jp.LM2Index('alm' , lmax, l, mp)[0] #-------------------------------------------------- self.beamlmax = [] for i in xrange(self.pointing.size) : verbose0 = self.verbose self.verbose = verbose Bmap = self.BeamMap(self.pointing[i], self.fwhm) Bmap = self.BeamMapComplex(0, Bmap, self.freq)[0] self.verbose = verbose0 beamlmtmp = [] #-------------------------------------------------- for j in xrange(Bmap.shape[0]) : almR = hp.map2alm(Bmap[j].real, lmax) almI = hp.map2alm(Bmap[j].imag, lmax) almds = np.zeros((lmax+1)**2, complex) # =beamlm #-------------------------------------------------- almds[idxdsn] = (-1)**morder * (np.conj(almR[idxmn]) + 1j*np.conj(almI[idxmn])) almds[idxdsp] = almR[idxmp] + 1j*almI[idxmp] #-------------------------------------------------- beamlmtmp.append( almds ) self.beamlmax.append(np.array(beamlmtmp)) # (Nv, lmax) self.beamlmax = np.array(self.beamlmax) if (self.verbose) : print return self.beamlmax # (Npoint, Nv, (lmax+1)**2)
def harmonic_ud_grade(hmap, nside): """ Decompose a map at a resolution nside_in into spherical harmonic components and then resynthesize the map at nside_out. """ npix_in = len(hmap) nside_in = hp.npix2nside(npix_in) lmax_in = 3 * nside_in - 1 hmap_out = hp.alm2map(hp.map2alm(hmap, lmax=lmax_in), nside, verbose=False) return hmap_out
def apply_ivf(self, det, tmap, pmap): mask_t = qcinv.util.load_map(self.mask_t) bl = self.bl pxw = hp.pixwin(self.nside)[0:self.lmax+1] tlm = hp.map2alm( tmap * mask_t, lmax=self.lmax, iter=0, regression=False ) hp.almxfl( tlm, self.ftl / bl / pxw, inplace=True ) return tlm
def remove_low_l(map1, mask1): map1m=hp.ma(map1) map1m.mask=np.logical_not(mask1) map2=np.ma.masked_values(map1, UNSEEN) alm2=hp.map2alm(map2, lmax=LMAX) fac2=np.array([1.]*(LMAX+1)) fac2[0:lREM]=0. alm2n=hp.sphtfunc.almxfl(alm2, fac2, inplace=False) map2new=hp.ma(hp.alm2map(alm2n, 2048)) map2new.mask=np.logical_not(mask1) return map2new
def test_map2alm_pol(self): tmp = [np.empty(o.size*2) for o in self.mapiqu] for t, o in zip(tmp, self.mapiqu): t[::2] = o maps = [self.mapiqu, [o.astype(np.float32) for o in self.mapiqu], [t[::2] for t in tmp]] for input in maps: alm = hp.map2alm(input, iter=10) output = hp.alm2map(alm, 32) for i, o in zip(input, output): np.testing.assert_allclose(i, o, atol=1e-4)
def TEB_to_TQU_maps(sky_TEB, lmax): nside = hp.get_nside(sky_TEB) alm = np.empty((3, (lmax + 1)**2)) for i in range(3): alm[i] = hp.map2alm(sky_TEB[i], lmax, pol=False) sky_TQU = hp.alm2map(alm, nside, lmax, pol=True) return sky_TQU
def calc_IP2_equil(Imap, Qmap, Umap, lmax=100): Tlm = hp.map2alm( Imap ) Elm,Blm = hp.map2alm_spin( (Qmap,Umap), 2 ) TEE = hp.alm2cl( Tlm, Elm**2 ) TBB = hp.alm2cl( Tlm, Blm**2 ) TEB = hp.alm2cl( Tlm, Elm*Blm ) ls = np.arange( len(TEE) ) return ls, TEE, TBB, TEB
def calc_prep(map, s_cls, n_inv_filt): tmap = np.copy(map) n_inv_filt.apply_map(tmap) lmax = len(n_inv_filt.b_transf) - 1 npix = len(map) alm = hp.map2alm(tmap, lmax=lmax, iter=0, regression=False) alm *= npix / (4.*np.pi) hp.almxfl( alm, n_inv_filt.b_transf, inplace=True ) return alm
def apply_ivf(self, det, tmap): mask_t = qcinv.util.load_map(self.mask_t) tlm = hp.map2alm( tmap * mask_t, lmax=self.lmax, iter=0, regression=False ) bl = dmc.get_bl(self.sim_lib.year, det)[0:self.lmax+1] pxw = hp.pixwin( self.sim_lib.nside )[0:self.lmax+1] ftl = self.get_ftl(det) hp.almxfl( tlm, ftl / bl / pxw, inplace=True ) return tlm
def iqu2teb(IQU, nside, lmax=None): alms = hp.map2alm(IQU, lmax=lmax, pol=True) return hp.alm2map(alms, nside=nside, lmax=lmax, pol=False)
sigma_0 = np.array([1.429, 1.466, 2.188, 3.131, 6.544]) # unit: mk N_obs = [ hp.read_map(data_path + 'wmap_band_smth_imap_r9_3yr_' + band + '_v2.fits', field=(1)) for band in band_name ] sigma = sigma_0.reshape(5, -1) / np.sqrt(N_obs) n_realization = 100 noise = 0 len_pix = len(sigma[0]) lmax = 1024 nside = 512 fwhm = [0.88, 0.66, 0.51, 0.35, 0.22] # degree n_band = len(band_name) alm_comb_n_smoothed = [] alm_comb_n = np.array([hp.map2alm(np.random.normal(nu,sigma[i],\ (n_realization,len_pix)),lmax=lmax,pol=False) for i in np.arange(n_band)]) np.save('alm_comb_noise', alm_comb_n) def beam_func(fwhm): ''' return a gaussian beam with specific fwhm and lmax ''' return hp.gauss_beam(fwhm=np.radians(fwhm), lmax=lmax) #one can also try hp.almxfl function to compute alm times B_ell def main(): ''' smoothing noise maps to the same angular resolution (1 degree) '''
def _get_sim_a_p(self, idx, joint=False, swapped=False): """Polarization rotation estimator. """ Q1, U1 = self.f2map1.get_irespmap(idx) if not swapped else self.f2map2.get_irespmap(idx) Q2, U2 = (self.f2map2.get_pmap(idx, joint=joint) if not swapped else self.f2map1.get_pmap(idx, joint=joint)) return -4. * hp.map2alm(Q1 * U2 - U1 * Q2 , lmax=self.get_lmax_qlm('P'), iter=0)
import matplotlib.pyplot as plt import fitsio as fs import gc Np = hp.nside2npix(2048) freqs = np.array([100, 143, 217, 353, 545, 857]) h = np.zeros((10, 8192)) maps = np.zeros((6, Np)) maps_filtered = np.zeros((6, Np)) alm = np.zeros((6, 33558528), dtype=complex) localpath = '/home/yanza15/research/Ghinshaw/ILC/' for j in range(6): freq = freqs[j] maps[j] = pf.open('/data/yanza15/sky_map/SkyMap_' + str(freqs[j]) + '_2048_full_i_smth10.fits')[1].data['I'].ravel() alm[j] = hp.map2alm(maps[j]) del maps gc.collect() for i in range(10): h[i] = np.loadtxt(localpath + 'results/needlet_' + str(i) + '.txt')[0:6142] for j in range(6): alm_filtered = hp.almxfl(alm[j], h[i]) maps_filtered[j] = hp.alm2map(alm_filtered, 2048) hp.write_map( localpath + 'maps/Planck_maps/Sky_maps/HFI_SkyMap_' + str(freqs[j]) + '_2048_R2.02_full_i_smth10_needlet' + str(i) + '.fits', maps_filtered[j])
def taylor_interpol_iter(m, pos, order=3, verbose=False, lmax=None): """Given a healpix map m[npix], and a set of positions pos[{theta,phi},...], evaluate the values at those positions using harmonic Taylor interpolation to the given order (3 by default). Successively yields values for each cumulative order up to the specified one. If verbose is specified, it will print progress information to stderr. """ nside = hp.npix2nside(m.size) if lmax is None: lmax = 3 * nside # Find the healpix pixel centers closest to pos, # and our deviation from these pixel centers. ipos = hp.ang2pix(nside, pos[0], pos[1]) pos0 = np.array(hp.pix2ang(nside, ipos)) dpos = pos[:2] - pos0 # Take wrapping into account bad = dpos[1] > np.pi dpos[1, bad] = dpos[1, bad] - 2 * np.pi bad = dpos[1] < -np.pi dpos[1, bad] = dpos[1, bad] + 2 * np.pi # Since healpix' dphi actually returns dphi/sintheta, we choose # to expand in terms of dphi*sintheta instead. dpos[1] *= np.sin(pos0[0]) del pos0 # We will now Taylor expand our healpix field to # get approximations for the values at our chosen # locations. The structure of this section is # somewhat complicated by the fact that alm2map_der1 returns # two different derivatives at the same time. derivs = [[m]] res = m[ipos] yield res for o in range(1, order + 1): # Compute our derivatives derivs2 = [None for i in range(o + 1)] used = [False for i in range(o + 1)] # Loop through previous level in steps of two (except last) if verbose: print("order %d" % o) for i in range(o): # Each alm2map_der1 provides two derivatives, so avoid # doing double work. if i < o - 1 and i % 2 == 1: continue a = hp.map2alm(derivs[i], use_weights=True, lmax=lmax, iter=0) derivs[i] = None dtheta, dphi = hp.alm2map_der1(a, nside, lmax=lmax)[-2:] derivs2[i:i + 2] = [dtheta, dphi] del a, dtheta, dphi # Use these to compute the next level for j in range(i, min(i + 2, o + 1)): if used[j]: continue N = comb(o, j) / factorial(o) res += N * derivs2[j][ipos] * dpos[0]**(o - j) * dpos[1]**j used[j] = True # If we are at the last order, we don't need to waste memory # storing the derivatives any more if o == order: derivs2[j] = None derivs = derivs2 yield res
def udgrade(x,nside_out): return hp.alm2map(hp.map2alm(x),nside_out, verbose=False)
def plotCl(healpixMapFileName, figureTitleNamePre, saveNamePre, pointCount, SIGNAL_DATA, MY_DOUBLE, spannedAngle, fignum, plotting=True, **kwargs): """ plot the angular power spectrum coeff SIGNAL_DATA, MY_DOUBLE no usage Parameters: -------- healpixMapFileName: str name of the data file figureTitleNamePre: str prefix of the title saveNamePre: str prefix of the to be saved figures return: dictionary, {'Nside', 'cl','pointsCount'} """ global figX, figY if (plotting == True): corrName = "spanned:%.4f" % (spannedAngle) + " points:" + str( pointCount) additionName = "" titleAddition = "" count = 0 for key, value in kwargs.items(): additionName += key + ":" + str(value) titleAddition += key + ":" + str(value) + ", " count += 1 if (count % 3 == 0): titleAddition += "\n" figureName = figureTitleNamePre + ' ' + corrName + "\n" + titleAddition saveName = saveNamePre + corrName + additionName hp1 = [] for line in open(healpixMapFileName, 'r'): # if(SIGNAL_DATA == False or MY_DOUBLE == False): # values = [float(s) for s in line.split()] # else: values = [float(s) for s in line.split()] hp1.append(values[0]) hpOrder = int(hp1[0]) hpPointCount = int(hp1[1]) pixVal = hp1[2:] pixValLen = len(pixVal) Nside = 2**hpOrder Npixel = hp.nside2npix(Nside) pixVal.extend([0] * (int(Npixel) - pixValLen)) pixVal = np.array(pixVal) if (hpPointCount <= 1): return None LMAX = Nside * 2 cl = hp.anafast(pixVal, lmax=LMAX) alm = hp.map2alm(pixVal, lmax=LMAX) ell = np.arange(len(cl)) coeff = (cl * (2 * ell + 1)) / ( (hpPointCount)**2) * 4 * np.pi - 1 / (hpPointCount) coeff2 = (cl * (2 * ell + 1)) / ((hpPointCount)**2) if (plotting == True): xMax = LMAX plt.figure(figsize=(figX, figY)) fig1, ax1 = plt.subplots(num=fignum + 1) plt.xlim(0, LMAX) ax1.xaxis.set_major_locator( plt.MultipleLocator(xMax / CL_MAJOR_TICKS_NUM)) ax1.xaxis.set_minor_locator( plt.MultipleLocator(xMax / (CL_MAJOR_TICKS_NUM * 2))) ax1.plot(ell, ell * (ell + 1) * cl) plt.xlabel("$\ell$") plt.ylabel("$\ell(\ell+1)C_{\ell}$") plt.grid() saveName1 = saveName + "LMAX:" + str(LMAX) + "CLcoeff_llp1.png" figureName1 = figureName + "LMAX:" + str(LMAX) + " l(l+1)_normalized" plt.title(figureName1, fontsize=8, y=0.99) plt.savefig(saveName1) # print(alm[0]) plt.figure(figsize=(figX, figY)) fig2, ax2 = plt.subplots(num=fignum + 2) ax2.xaxis.set_major_locator( plt.MultipleLocator(xMax / CL_MAJOR_TICKS_NUM)) ax2.xaxis.set_minor_locator( plt.MultipleLocator(xMax / (CL_MAJOR_TICKS_NUM * 2))) normedCl = (2 * ell + 1) * cl ax2.plot(ell, normedCl) plt.xlabel("$\ell$") plt.ylabel("$(2\ell+1)C_{\ell}$") plt.grid() saveName2 = saveName + "LMAX:" + str(LMAX) + "CLcoeff_2lp1.png" figureName2 = figureName + "LMAX:" + str(LMAX) + " (2l+1)_normalized" plt.title(figureName2, fontsize=8, y=0.99) #find local max indexX = localMax(ell, normedCl, ax2) maxXVal = ell[indexX] maxYVal = normedCl[indexX] plt.stem(maxXVal, maxYVal, linefmt='b--', markerfmt='ro', basefmt=' ') plt.savefig(saveName2) plt.figure(figsize=(figX, figY)) fig3, ax3 = plt.subplots(num=fignum + 3) ax3.xaxis.set_major_locator( plt.MultipleLocator(xMax / CL_MAJOR_TICKS_NUM)) ax3.xaxis.set_minor_locator( plt.MultipleLocator(xMax / (CL_MAJOR_TICKS_NUM * 2))) ax3.plot(ell, coeff) plt.xlabel("$\ell$") plt.ylabel("$\widehat{c_{\ell}}$") plt.grid() saveName3 = saveName + "LMAX:" + str(LMAX) + "CLcoeff_coeff.png" figureName3 = figureName + "LMAX:" + str(LMAX) + " legendre coeff" plt.title(figureName3, fontsize=8, y=0.99) plt.savefig(saveName3) plt.figure(figsize=(figX, figY)) fig4, ax4 = plt.subplots(num=fignum + 4) ax4.xaxis.set_major_locator( plt.MultipleLocator(xMax / CL_MAJOR_TICKS_NUM)) ax4.xaxis.set_minor_locator( plt.MultipleLocator(xMax / (CL_MAJOR_TICKS_NUM * 2))) ax4.plot(ell, cl) plt.xlabel("$\ell$") plt.ylabel("$C_{\ell}$") plt.grid() saveName4 = saveName + "LMAX:" + str(LMAX) + "CLcoeff_rawCL.png" figureName4 = figureName + "LMAX:" + str(LMAX) + " Cl" plt.title(figureName4, fontsize=8, y=0.99) plt.savefig(saveName4) else: return {'Nside': Nside, 'cl': cl, 'pointsCount': hpPointCount}
def map2alm_spin(maps, spin, lmax=None, mmax=None): assert spin >= 0, spin if spin > 0: return hp.map2alm_spin(maps, spin, lmax=lmax, mmax=mmax) else: return -hp.map2alm(maps[0], lmax=lmax, mmax=mmax, iter=0), 0.
allmaps = sky.signal()(nu) if verbose: print('Microwave sky simulated') T = np.array(allmaps[0], dtype=float) * mapFactor Q = np.array(allmaps[1], dtype=float) * mapFactor U = np.array(allmaps[2], dtype=float) * mapFactor #smoothing with gaussian psf t = hp.smoothing(map_in=T, fwhm=fwhmrad, verbose=False) q = hp.smoothing(map_in=Q, fwhm=fwhmrad, verbose=False) u = hp.smoothing(map_in=U, fwhm=fwhmrad, verbose=False) if verbose: print('Maps smoothed') alms = hp.map2alm([t, q, u]) emap = hp.alm2map(alms[1], nside=nside, verbose=False) bmap = hp.alm2map(alms[2], nside=nside, verbose=False) def vec2pix(x, y, z): """ Auxiliar function for projection. """ return hp.vec2pix(nside, x, y, z) epatches = [] bpatches = [] for h in np.arange(0, len(pos), 1, dtype=int): #coordinate limits that define each patch
def dot(self, tmap): npix = len(tmap) return alm_to_xyz(hp.map2alm(tmap, lmax=1, iter=0)) * npix / 3.
def rotate_map_to_axis(m, ra, dec, nest=False, method='direct'): """Rotate a sky map to place a given line of sight on the +z axis. Parameters ---------- m : np.ndarray The input HEALPix array. ra : float Right ascension of axis in radians. To specify the axis in geocentric coordinates, supply ra=(lon + gmst), where lon is the geocentric longitude and gmst is the Greenwich mean sidereal time in radians. dec : float Declination of axis in radians. To specify the axis in geocentric coordinates, supply dec=lat, where lat is the geocentric latitude in radians. nest : bool, default=False Indicates whether the input sky map is in nested rather than ring-indexed HEALPix coordinates (default: ring). method : 'direct' or 'fft' Select whether to use spherical harmonic transformation ('fft') or direct coordinate transformation ('direct') Returns ------- m_rotated : np.ndarray The rotated HEALPix array. """ npix = len(m) nside = hp.npix2nside(npix) theta = 0.5 * np.pi - dec phi = ra if method == 'fft': if nest: m = hp.reorder(m, n2r=True) alm = hp.map2alm(m) hp.rotate_alm(alm, -phi, -theta, 0.0) ret = hp.alm2map(alm, nside, verbose=False) if nest: ret = hp.reorder(ret, r2n=True) elif method == 'direct': R = hp.Rotator( rot=np.asarray([0, theta, -phi]), deg=False, inv=False, eulertype='Y') theta, phi = hp.pix2ang(nside, np.arange(npix), nest=nest) ipix = hp.ang2pix(nside, *R(theta, phi), nest=nest) ret = m[ipix] else: raise ValueError('Unrecognized method: {0}'.format(method)) return ret
def lens_tlm(tlm,dlm,lmaxout = None,verbose = True,nside = 2048,nband = 16,facres = 0,iter = 0): # FIXME : suppress the stupid intermediate step lenmap = tlm2lensmap(nside,tlm,dlm,verbose=verbose,nband=nband,facres=facres) return hp.map2alm(lenmap,lmax = (lmaxout or hp.Alm.getlmax(tlm.size)),iter = iter)
def make_ijones_spectrum(parameters_dict, verbose=False): p = Parameters(parameters_dict) """ nu_axis: frequency in Hz """ fmax = int(p.nu_axis[-1] / 1e6) fmin = int(p.nu_axis[0] / 1e6) nfreq = len(p.nu_axis) nnodes = fmax - fmin + 1 nu_nodes = np.array([fmin + x for x in range(nnodes)]) lmax = 3 * p.nside - 1 nlm = hp.Alm.getsize(lmax) joneslm = np.zeros((nnodes, nlm, 2, 2, 2), dtype=np.complex128) sht = lambda x: hp.map2alm(x, lmax=lmax) comp = [np.real, np.imag] u = [1, 1j] if verbose == True: print "Freq. min/max:", fmin, fmax print "nnodes: ", nnodes print "len(nu_nodes): ", len(nu_nodes) # synthesize maps at the nside to be used in the simulation for each frequency node # This is necessary because the basis transformation is done at nside 1024 to minimize # the topological error at the center of the beam. But for the frequency interpolation # this resolution would probably use too much memory. # note that the output of jones_f() is a beam with zenith at -31 deg latitude for n in range(nnodes): if verbose == True: print "Loading jones node ", n jones_node = jones_f(nu_nodes[n], p.nside) for i in range(2): for j in range(2): for k in range(2): joneslm[n, :, i, j, k] = sht(comp[k](jones_node[:, i, j])) joneslm_re = joneslm.real joneslm_im = joneslm.imag if verbose == True: print joneslm_re.shape print joneslm_im.shape print nu_nodes.shape interpolant_re = interpolate.interp1d(nu_nodes, joneslm_re, kind='cubic', axis=0) interpolant_im = interpolate.interp1d(nu_nodes, joneslm_im, kind='cubic', axis=0) freqs_out = p.nu_axis / 1e6 joneslm_re_int = interpolant_re(freqs_out) joneslm_im_int = interpolant_im(freqs_out) joneslm_int = joneslm_re_int + 1j * joneslm_im_int # now we just need to resynthesize at each frequency and we're done isht = lambda x: hp.alm2map( np.ascontiguousarray(x), p.nside, verbose=False) z0_cza = np.radians(120.7215) ijones = np.zeros((p.nfreq, p.npix, 2, 2), dtype=np.complex128) for n in range(p.nfreq): for i in range(2): for j in range(2): ijones[n, :, i, j] = isht( joneslm_int[n, :, i, j, 0]) + 1j * isht(joneslm_int[n, :, i, j, 1]) If = abs(ijones[n, :, 0, 0])**2. + abs(ijones[n, :, 0, 1])**2. + abs( ijones[n, :, 0, 1])**2. + abs(ijones[n, :, 1, 0])**2 norm = np.sqrt(np.amax(If)) ijones[n] /= norm ijones[n] *= horizon_mask(ijones[n].squeeze(), z0_cza) if verbose == True: print "norm is:", norm return ijones
def teb2iqu(TEB, nside, lmax=None): alms = hp.map2alm(TEB, lmax=lmax, pol=False) return hp.alm2map(alms, nside=nside, lmax=lmax, pol=True)
def plotDiffCl(healpixMapFileName, randomMapFileName, figureTitleNamePre, saveNamePre, pointCount, SIGNAL_DATA, MY_DOUBLE, spannedAngle, fignum, **kwargs): """ plot the angular power spectrum coeff subtracted from a randomly generated map Parameters: -------- healpixMapFileName: str name of the data file randomMapFileName: str name of the random Map file figureTitleNamePre: str prefix of the title saveNamePre: str prefix of the to be saved figures """ global figX, figY corrName = "spanned:%.4f" % (spannedAngle) + " points:" + str(pointCount) additionName = "" titleAddition = "" count = 0 for key, value in kwargs.items(): additionName += key + ":" + str(value) titleAddition += key + ":" + str(value) + ", " count += 1 if (count % 3 == 0): titleAddition += "\n" figureName = figureTitleNamePre + ' ' + corrName + "\n" + titleAddition saveName = saveNamePre + corrName + additionName hp1 = [] for line in open(healpixMapFileName, 'r'): if (SIGNAL_DATA == False or MY_DOUBLE == False): values = [float(s) for s in line.split()] else: values = [float(s) for s in line.split()] if (len(values) >= 1): hp1.append(values[0]) hpOrder = int(hp1[0]) hpPointCount = int(hp1[1]) if (hpPointCount <= 1): print("healpix map empty, fileName: " + healpixMapFileName) return pixVal = hp1[2:] pixValLen = len(pixVal) Nside = 2**hpOrder Npixel = hp.nside2npix(Nside) pixVal.extend([0] * (int(Npixel) - pixValLen)) pixVal = np.array(pixVal) LMAX = Nside * 2 # read in random Map hp2 = [] for line in open(randomMapFileName, 'r'): values = [float(s) for s in line.split()] if (len(values) >= 1): hp2.append(values[0]) hp2Order = int(hp2[0]) if (not hpOrder == hp2Order): print("two maps not of the same order") return hp2PointCount = int(hp2[1]) if (hp2PointCount <= 1): print("random map empty, fileName: " + randomMapFileName) return pix2Val = hp2[2:] pix2ValLen = len(pix2Val) pix2Val.extend([0] * (int(Npixel) - pix2ValLen)) pix2Val = np.array(pix2Val) cl = hp.anafast(pixVal, lmax=LMAX) alm = hp.map2alm(pixVal, lmax=LMAX) ell = np.arange(len(cl)) # coeff = (cl * (2 * ell + 1))/((hpPointCount)**2) * 4 * np.pi - 1/( hpPointCount) # coeff2 = (cl * (2 * ell + 1)) / ((hpPointCount)**2) cl2 = hp.anafast(pix2Val, lmax=LMAX) # ell2 = np.arange(len(cl2)) # coeffRandom = (cl * (2*ell + 1))/((hp2PointCount)**2)* if (len(cl) != len(cl2)): print("len(cl) != len(cl2)") return clFinal = cl - cl2 xMax = LMAX plt.figure(figsize=(figX, figY)) fig1, ax1 = plt.subplots(num=fignum + 1) ax1.xaxis.set_major_locator(plt.MultipleLocator(xMax / CL_MAJOR_TICKS_NUM)) ax1.xaxis.set_minor_locator( plt.MultipleLocator(xMax / (CL_MAJOR_TICKS_NUM * 2))) ax1.plot(ell, ell * (ell + 1) * clFinal) plt.xlabel("$\ell$") plt.ylabel("$\ell(\ell+1)C_{\ell}$") plt.grid() annot_max(ell, ell * (ell + 1) * clFinal, ax1) saveName1 = saveName + "Diff_LMAX:" + str(LMAX) + "CLcoeff_llp1.png" figureName1 = figureName + "LMAX:" + str( LMAX) + " l(l+1)_normalized\nrandom Map offset" plt.title(figureName1, fontsize=8, y=0.99) plt.savefig(saveName1) # print(alm[0]) plt.figure(figsize=(figX, figY)) fig2, ax2 = plt.subplots(num=fignum + 2) ax2.xaxis.set_major_locator(plt.MultipleLocator(xMax / CL_MAJOR_TICKS_NUM)) ax2.xaxis.set_minor_locator( plt.MultipleLocator(xMax / (CL_MAJOR_TICKS_NUM * 2))) ax2.plot(ell, (2 * ell + 1) * clFinal) normedCl = (2 * ell + 1) * clFinal plt.xlabel("$\ell$") plt.ylabel("$(2\ell+1)C_{\ell}$") annot_max(ell, (2 * ell + 1) * clFinal, ax2) plt.grid() saveName2 = saveName + "Diff_LMAX:" + str(LMAX) + "CLcoeff_2lp1.png" figureName2 = figureName + "LMAX:" + str( LMAX) + " (2l+1)_normalized\nrandom Map offset" plt.title(figureName2, fontsize=8, y=0.99) #find local max indexX = localMax(ell, normedCl, ax2) maxXVal = ell[indexX] maxYVal = normedCl[indexX] plt.stem(maxXVal, maxYVal, linefmt='b--', markerfmt='ro', basefmt=' ') plt.savefig(saveName2) plt.savefig(saveName2) # plt.figure(figsize= (figX, figY)) # plt.plot(ell, coeff) # plt.xlabel("$\ell$") # plt.ylabel("$\widehat{c_{\ell}}$") # plt.grid() # saveName3= saveName + "LMAX:" + str(LMAX) + "CLcoeff_coeff.png" # figureName3 = figureName + "LMAX:" + str(LMAX) + " legendre coeff" # plt.title(figureName3,fontsize = 8, y = 0.99) # plt.savefig(saveName3) plt.figure(figsize=(figX, figY)) fig3, ax3 = plt.subplots(num=fignum + 3) ax3.xaxis.set_major_locator(plt.MultipleLocator(xMax / CL_MAJOR_TICKS_NUM)) ax3.xaxis.set_minor_locator( plt.MultipleLocator(xMax / (CL_MAJOR_TICKS_NUM * 2))) ax3.plot(ell, clFinal) plt.xlabel("$\ell$") plt.ylabel("$C_{\ell}$") annot_max(ell, clFinal, ax3) plt.grid() saveName4 = saveName + "Diff_LMAX:" + str(LMAX) + "CLcoeff_rawCL.png" figureName4 = figureName + "LMAX:" + str(LMAX) + " Cl\nrandom Map offset" plt.title(figureName4, fontsize=8, y=0.99) plt.savefig(saveName4)
lmax = 1024 maps = [] alms = [] mk2uk = 1000 map_path = r'/home/wudl/project/ILC/fits_files/wmap/' def beam_func(fwhm): return hp.gauss_beam(fwhm=np.radians(fwhm), lmax=lmax) for i in np.arange(5): ''' load 5 maps, note that all the maps are smoothed to 1 degree. ''' T_map = hp.read_map(map_path+'wmap_band_smth_imap_r9_3yr_{0}_v2.fits'.format(bandname[i])) maps.append(T_map) alms.append(hp.map2alm(T_map)) hp.mollview(T_map,sub=(2,3,i+1),unit=r'mK$_\mathrm{CMB}$',norm='hist',min=-0.4,max=0.4,title= bandname[i] + "-band") map_cov = np.cov(maps) print('map_cov:>>> ',map_cov) weight = [] map_cov_inv = np.linalg.inv(map_cov) for i in range(5): weight.append(np.sum(map_cov_inv[i])/np.sum(map_cov_inv)) #print weight print(np.array(maps).shape) # shape of the data array print(weight,np.sum(weight)) # get clean map map_clean = np.sum(np.array(weight).reshape(5,-1)*maps,axis=0)
def psd(x): """Compute the Power Spectral Density for heaply maps.""" if len(x.shape) == 2 and x.shape[1] > 1: return np.stack([psd(x[ind, ]) for ind in range(len(x))]) hatx = hp.map2alm(hp.reorder(x, n2r=True)) return hp.alm2cl(hatx)
def check_cl_sims( nmaps=1, lmax=1000, nside=2048, read_file=False, filename='testsky.fits', frequency=100, beam=None, beamP=None, smear=True, nonoise=False, cl_file='bf_base_cmbonly_plikHMv18_TT_lowTEB_lmax4000.minimum.theory_cl' ): if read_file and os.path.exists(data_path + filename): Tmap, Qmap, Umap = hp.read_map(data_path + filename, field=(0, 1, 2)) else: if nonoise: Tmap, Qmap, Umap = simulate_cmb(nside=nside, lmax=lmax, save=False, smear=smear, beam=beam, beamP=beamP, cl_file=cl_file) else: Tmap, Qmap, Umap = observe_cmb_sky(save=False, nside=nside, npix=None, lmax=3000, frequency=frequency, beam=beam, beamP=beamP, cl_file=cl_file) Tlm = hp.map2alm(Tmap, lmax=lmax) Elm, Blm = hp.map2alm_spin((Qmap, Umap), 2, lmax=lmax) if smear: if (beam is None) or (beamP is None): hdulist = fits.open(data_path + 'HFI_RIMO_Beams-100pc_R2.00.fits') beam = hdulist[beam_index['{}'.format( frequency)]].data.NOMINAL[0][:lmax + 1] beamP = hdulist[beam_index['{}P'.format( frequency)]].data.NOMINAL[0][:lmax + 1] hp.sphtfunc.almxfl(Tlm, 1. / beam, inplace=True) hp.sphtfunc.almxfl(Elm, 1. / beamP, inplace=True) hp.sphtfunc.almxfl(Blm, 1. / beamP, inplace=True) ls = np.arange(lmax + 1) factor = ls * (ls + 1.) / (2. * np.pi) cltt = hp.alm2cl(Tlm) * factor clee = hp.alm2cl(Elm) * factor clbb = hp.alm2cl(Blm) * factor clte = hp.alm2cl(Tlm, Elm) * factor cl = get_theory_cmb() ls_theory = cl[0][:lmax + 1] factor_theory = ls_theory * (ls_theory + 1.) / (2. * np.pi) cltt_theory = cl[1][:lmax + 1] * factor_theory clee_theory = cl[2][:lmax + 1] * factor_theory clbb_theory = cl[3][:lmax + 1] * factor_theory clte_theory = cl[4][:lmax + 1] * factor_theory plt.figure() plt.plot(ls, cltt, label='sims') plt.plot(ls_theory, cltt_theory, label='theory TT') plt.legend() plt.figure() plt.plot(ls, clte, label='sims') plt.plot(ls_theory, clte_theory, label='theory TE') plt.legend() plt.figure() plt.plot(ls, clee, label='sims') plt.plot(ls_theory, clee_theory, label='theory EE') plt.legend() plt.figure() plt.plot(ls, clbb, label='sims') plt.plot(ls_theory, clbb_theory, label='theory BB') plt.legend()
def mkconstrained(corr, constraints, nside): """Construct a set of Healpix maps, satisfying given constraints on specified frequency slices, by using the lowest eigenmodes. Parameters ---------- corr : np.ndarray (lmax+1, numz, numz) The correlation matrix :math:`C_l(z, z')`. constrains : list A list of constraints packed as [[frequency_index, healpix map], ...] nside : integer The resolution of the Healpix maps. Returns ------- hpmaps : np.ndarray (numz, npix) The Healpix maps. hpmaps[i] is the i'th map. """ numz = corr.shape[1] maxl = corr.shape[0] - 1 larr, marr = healpy.Alm.getlm(maxl) matshape = larr.shape + (numz, ) # The number of constraints nmodes = len(constraints) # The frequency slices that are constrained. f_ind = zip(*constraints)[0] if corr.shape[2] != numz: raise Exception("Correlation matrix is incorrect shape.") trans = np.zeros((corr.shape[0], nmodes, corr.shape[2])) tmat = np.zeros((corr.shape[0], nmodes, nmodes)) cmap = np.zeros(larr.shape + (nmodes, ), dtype=np.complex128) cv = np.zeros((numz, ) + larr.shape, dtype=np.complex128) # Find eigenmodes, extract the largest nmodes (enough to satisfy # constraints), and then pull out coefficients for each constrained # frequency. for i in range(maxl + 1): trans[i] = la.eigh(corr[i])[1][:, -nmodes:].T tmat[i] = trans[i][:, f_ind] # Switch constraint maps into harmonic space for i, cons in enumerate(constraints): cmap[:, i] = healpy.map2alm(cons[1], lmax=maxl) # Solve for the eigenmode amplitudes to satisfy constraints, and project # each mode across the whole frequency range. for i, l in enumerate(larr): if l == 0: cv[:, i] = 0.0 else: cv[:, i] = np.dot(trans[l].T, la.solve(tmat[l].T, cmap[i])) hpmaps = np.empty((numz, healpy.nside2npix(nside))) for i in range(numz): hpmaps[i] = healpy.alm2map(cv[i], nside, verbose=False) return hpmaps
def _get_sim_f_p(self, idx, joint=False, swapped=False): """Modulation estimator, polarization only. """ Q1, U1 = self.f2map1.get_irespmap(idx) if not swapped else self.f2map2.get_irespmap(idx) Q2, U2 = (self.f2map2.get_pmap(idx, joint=joint) if not swapped else self.f2map1.get_pmap(idx, joint=joint)) return -2 * hp.map2alm(Q1 * Q2 + U1 * U2 , lmax=self.get_lmax_qlm('P'), iter=0)
sim_tau = hp.read_map(sim_tau_file) print('...done...') # CMB maps print('...loading CMB maps...') sim_tt1 = hp.read_map(sim_tt_file) sim_tt1 = np.exp(-sim_tau) * sim_tt1 sim_tt1 = hp.smoothing(sim_tt1, fwhm=np.radians( fwhm / 60.)) # Apply beam to signal-only map if wnoise: sim_ntt1 = hp.read_map(sim_ntt1_file) sim_ntt2 = hp.read_map(sim_ntt2_file) sim_tt1 = sim_tt1 + sim_ntt1 sim_tt2 = sim_tt1 + sim_ntt2 sim_tt1_alm = hp.map2alm(sim_tt1, lmax=lmax) sim_tt1 = hp.alm2map(hp.almxfl(sim_tt1_alm, filt), hp.npix2nside(len(sim_tt1)), lmax=lmax) if wnoise: sim_tt2_alm = hp.map2alm(sim_tt2, lmax=lmax) sim_tt2 = hp.alm2map(hp.almxfl(sim_tt2_alm, filt), hp.npix2nside(len(sim_tt2)), lmax=lmax) print('...done...') # Mask print('...loading CMB masks...') mask_gal = hp.reorder(fits.getdata(mask_gal_file, hdu=1)['GAL080'], inp='NESTED', out='RING')
def rotate_map_g_c(map_in, c2g=False): ns = hp.npix2nside(len(map_in)) alm_in = hp.map2alm(map_in) alm_out = rotate_alm_g_c(alm_in, c2g=False) return hp.alm2map(alm_out, ns, verbose=False)
def udgrade(x, nside_out): """ Spatial interpolation of a healpix map x using spherical harmonic decomposition and then synthesis at resolution nside_out. """ return hp.alm2map(hp.map2alm(x), nside_out, verbose=False)
N_NU = 30 # get the spetrum of frequenies covered in units of MHz (bn,nu_bot,nu_top,z_bot,z_top) = np.loadtxt("./sim_info/nuTable.txt").T nu_arr = ((nu_bot + nu_top)/2.)[:-1] nu_arr = np.array([np.mean(i,axis=0) for i in np.split(nu_arr,N_NU)]) pca = np.load("sim_data/x_val_nepochs100.npy") cosmo = np.load("sim_data/y_val_nepochs100.npy") pred = np.load("sim_data/y_pred_nepochs100.npy") rearr = np.array(np.load("rearr.npy"),dtype=int) for i in range(N_NU): # Get Cls for PCA spectrum pca0 = (pca.T[i].T).flatten() pca0 = pca0[rearr] alm_pca = hp.map2alm(pca0) Cl_pca = hp.alm2cl(alm_pca) # Get Cls for COSMO spectrum cosmo0 = (cosmo.T[i].T).flatten() cosmo0 = cosmo0[rearr] alm_cosmo = hp.map2alm(cosmo0) Cl_cosmo = hp.alm2cl(alm_cosmo) # Get Cls for PCA spectrum pred0 = (pred.T[i].T).flatten() pred0 = pred0[rearr] alm_pred = hp.map2alm(pred0) Cl_pred = hp.alm2cl(alm_pred) fig = plt.figure() plt.plot(((Cl_pca-Cl_cosmo)/Cl_cosmo)[1:],c=plt.cm.bwr(.9),label="PCA")
def _get_sim_stt(self, idx, swapped=False): """Point source estimator """ tmap1 = self.f2map1.get_irestmap(idx) if not swapped else self.f2map2.get_irestmap(idx) # healpy map tmap1 *= (self.f2map2.get_irestmap(idx) if not swapped else self.f2map1.get_irestmap(idx)) # healpy map return -0.5 * hp.map2alm(tmap1, lmax=self.get_lmax_qlm('PS'), iter=0)
".dat", "r"))) norm2 = np.array( pickle.load( open(foldername + "norm2_32_360_iteration" + str(Nstart) + ".dat", "r"))) Emap2 = np.array( pickle.load( open( foldername + "exposure2_32_360_iteration" + str(Nstart) + ".dat", "r"))) namefits = foldername + 'CR_32_360_iteration' + str(Nstart) + '.fits' diffCRmap = H.read_map(namefits) LMAX = 180 alms3 = H.map2alm(diffCRmap, lmax=3) #fitmap3 = H.alm2map(alms3, nside,lmax=LMAX) fitmap3 = H.alm2map(alms3, nside) diffCRmap = CRmap - fitmap3 # substract l<=3 subLMAX = 3 redLMAX = 3 out = H.anafast(tempmap, alm=True, lmax=subLMAX) outr = H.anafast(tempmap, alm=True, lmax=redLMAX) submap = H.alm2map(out[1], nside, lmax=subLMAX) diffCRmap = diffCRmap - submap # calculate new norm
def _get_sim_ntt(self, idx, swapped=False): """ Noise inhomogeneity estimator (same as point-source estimator but acting on beam-deconvolved maps) """ f1 = self.f2map1 if not swapped else self.f2map2 f2 = self.f2map2 if not swapped else self.f2map1 tmap1 = f1.get_wirestmap(idx, f1.ivfs.get_tal('t')[:]) * f2.get_wirestmap(idx, f2.ivfs.get_tal('t')[:]) return -0.5 * hp.map2alm(tmap1, lmax=self.get_lmax_qlm('T'), iter=0)
def _get_sim_ftt(self, idx, joint=False, swapped=False): """Modulation estimator, temperature only.""" tmap1 = self.f2map1.get_irestmap(idx) if not swapped else self.f2map2.get_irestmap(idx) # healpy map tmap1 *= (self.f2map2.get_tmap(idx, joint=joint) if not swapped else self.f2map1.get_tmap(idx, joint=joint)) # healpy map return -hp.map2alm(tmap1, lmax=self.get_lmax_qlm('T'), iter=0)
def xForecast(components, instrument, d_fgs, lmin, lmax, Alens=1.0, r=0.001, make_figure=False, **minimize_kwargs): """ xForecast Run XForcast (Stompor et al, 2016) using the provided instrumental specifications and input foregrounds maps. If the foreground maps match the components provided (constant spectral indices are assumed), it reduces to CMB4cast (Errard et al, 2011). Currently, only polarization is considered fot component separation and only the BB power spectrum for cosmological analysis. Parameters ---------- components: list `Components` of the mixing matrix instrument: Object that provides the following as a key or an attribute. - **frequency** - **depth_p** (optional, frequencies are inverse-noise weighted according to these noise levels) - **fwhm** (optional) They can be anything that is convertible to a float numpy array. d_fgs: ndarray The foreground maps. No CMB. Shape `(n_freq, n_stokes, n_pix)`. If some pixels have to be masked, set them to zero. Since (cross-)spectra of the maps will be computed, you might want to apodize your mask (use the same apodization for all the frequency). lmin: int minimum multipole entering the likelihood computation lmax: int maximum multipole entering the likelihood computation Alens: float Amplitude of the lensing B-modes entering the likelihood on r r: float tensor-to-scalar ratio assumed in the likelihood on r minimize_kwargs: dict Keyword arguments to be passed to `scipy.optimize.minimize` during the fitting of the spectral parameters. A good choice for most cases is `minimize_kwargs = {'tol': 1, options: {'disp': True}}`. `tol` depends on both the solver and your signal to noise: it should ensure that the difference between the best fit -logL and and the minimum is well less then 1, without exagereting (a difference of 1e-4 is useless). `disp` also triggers a verbose callback that monitors the convergence. Returns ------- xFres: dict xForecast result. It includes - the fitted spectral parameters - noise-averaged post-component separation CMB power spectrum - noise spectrum - statistical residuals spectrum - systematic residuals spectrum - noise-averaged cosmological likelihood """ # Preliminaries instrument = standardize_instrument(instrument) nside = hp.npix2nside(d_fgs.shape[-1]) n_stokes = d_fgs.shape[1] n_freqs = d_fgs.shape[0] invN = np.diag(hp.nside2resol(nside, arcmin=True) / (instrument.depth_p))**2 mask = d_fgs[0, 0, :] != 0. fsky = mask.astype(float).sum() / mask.size ell = np.arange(lmin, lmax + 1) print('fsky = ', fsky) ############################################################################ # 1. Component separation using the noise-free foregrounds templare # grab the max-L spectra parameters with the associated error bars print('======= ESTIMATION OF SPECTRAL PARAMETERS =======') A = MixingMatrix(*components) A_ev = A.evaluator(instrument.frequency) A_dB_ev = A.diff_evaluator(instrument.frequency) x0 = np.array([x for c in components for x in c.defaults]) if n_stokes == 3: # if T and P were provided, extract P d_comp_sep = d_fgs[:, 1:, :] else: d_comp_sep = d_fgs res = comp_sep(A_ev, d_comp_sep.T, invN, A_dB_ev, A.comp_of_dB, x0, **minimize_kwargs) res.params = A.params res.s = res.s.T A_maxL = A_ev(res.x) A_dB_maxL = A_dB_ev(res.x) A_dBdB_maxL = A.diff_diff_evaluator(instrument.frequency)(res.x) print('res.x = ', res.x) ############################################################################ # 2. Estimate noise after component separation ### A^T N_ell^-1 A print('======= ESTIMATION OF NOISE AFTER COMP SEP =======') i_cmb = A.components.index('CMB') Cl_noise = _get_Cl_noise(instrument, A_maxL, lmax)[i_cmb, i_cmb, lmin:] ############################################################################ # 3. Compute spectra of the input foregrounds maps ### TO DO: which size for Cl_fgs??? N_spec != 1 ? print('======= COMPUTATION OF CL_FGS =======') if n_stokes == 3: d_spectra = d_fgs else: # Only P is provided, add T for map2alm d_spectra = np.zeros((n_freqs, 3, d_fgs.shape[2]), dtype=d_fgs.dtype) d_spectra[:, 1:] = d_fgs # Compute cross-spectra almBs = [ hp.map2alm(freq_map, lmax=lmax, iter=10)[2] for freq_map in d_spectra ] Cl_fgs = np.zeros((n_freqs, n_freqs, lmax + 1), dtype=d_fgs.dtype) for f1 in range(n_freqs): for f2 in range(n_freqs): if f1 > f2: Cl_fgs[f1, f2] = Cl_fgs[f2, f1] else: Cl_fgs[f1, f2] = hp.alm2cl(almBs[f1], almBs[f2], lmax=lmax) Cl_fgs = Cl_fgs[..., lmin:] / fsky ############################################################################ # 4. Estimate the statistical and systematic foregrounds residuals print('======= ESTIMATION OF STAT AND SYS RESIDUALS =======') W_maxL = W(A_maxL, invN=invN)[i_cmb, :] W_dB_maxL = W_dB(A_maxL, A_dB_maxL, A.comp_of_dB, invN=invN)[:, i_cmb] W_dBdB_maxL = W_dBdB(A_maxL, A_dB_maxL, A_dBdB_maxL, A.comp_of_dB, invN=invN)[:, :, i_cmb] V_maxL = np.einsum('ij,ij...->...', res.Sigma, W_dBdB_maxL) # Check dimentions assert ((n_freqs, ) == W_maxL.shape == W_dB_maxL.shape[1:] == W_dBdB_maxL.shape[2:] == V_maxL.shape) assert (len(res.params) == W_dB_maxL.shape[0] == W_dBdB_maxL.shape[0] == W_dBdB_maxL.shape[1]) # elementary quantities defined in Stompor, Errard, Poletti (2016) Cl_xF = {} Cl_xF['yy'] = _utmv(W_maxL, Cl_fgs.T, W_maxL) # (ell,) Cl_xF['YY'] = _mmm(W_dB_maxL, Cl_fgs.T, W_dB_maxL.T) # (ell, param, param) Cl_xF['yz'] = _utmv(W_maxL, Cl_fgs.T, V_maxL) # (ell,) Cl_xF['Yy'] = _mmv(W_dB_maxL, Cl_fgs.T, W_maxL) # (ell, param) Cl_xF['Yz'] = _mmv(W_dB_maxL, Cl_fgs.T, V_maxL) # (ell, param) # bias and statistical foregrounds residuals res.noise = Cl_noise res.bias = Cl_xF['yy'] + 2 * Cl_xF['yz'] # S16, Eq 23 res.stat = np.einsum('ij, lij -> l', res.Sigma, Cl_xF['YY']) # E11, Eq. 12 res.var = res.stat**2 + 2 * np.einsum( 'li, ij, lj -> l', # S16, Eq. 28 Cl_xF['Yy'], res.Sigma, Cl_xF['Yy']) ############################################################################### # 5. Plug into the cosmological likelihood print('======= OPTIMIZATION OF COSMO LIKELIHOOD =======') Cl_fid = {} Cl_fid['BB'] = _get_Cl_cmb(Alens=Alens, r=r)[2][lmin:lmax + 1] Cl_fid['BuBu'] = _get_Cl_cmb(Alens=0.0, r=1.0)[2][lmin:lmax + 1] Cl_fid['BlBl'] = _get_Cl_cmb(Alens=1.0, r=0.0)[2][lmin:lmax + 1] res.BB = Cl_fid['BB'] * 1.0 res.BuBu = Cl_fid['BuBu'] * 1.0 res.BlBl = Cl_fid['BlBl'] * 1.0 res.ell = ell if make_figure: fig = pl.figure(figsize=(14, 12), facecolor='w', edgecolor='k') ax = pl.gca() left, bottom, width, height = [0.2, 0.2, 0.15, 0.2] ax0 = fig.add_axes([left, bottom, width, height]) ax0.set_title(r'$\ell_{\min}=$'+str(lmin)+\ r'$ \rightarrow \ell_{\max}=$'+str(lmax), fontsize=16) ax.loglog(ell, Cl_fid['BB'], color='DarkGray', linestyle='-', label='BB tot', linewidth=2.0) ax.loglog(ell, Cl_fid['BuBu'] * r, color='DarkGray', linestyle='--', label='primordial BB for r=' + str(r), linewidth=2.0) ax.loglog(ell, res.stat, 'DarkOrange', label='statistical residuals', linewidth=2.0) ax.loglog(ell, res.bias, 'DarkOrange', linestyle='--', label='systematic residuals', linewidth=2.0) ax.loglog(ell, res.noise, 'DarkBlue', linestyle='--', label='noise after component separation', linewidth=2.0) ax.legend() ax.set_xlabel('$\ell$', fontsize=20) ax.set_ylabel('$C_\ell$ [$\mu$K-arcmin]', fontsize=20) ax.set_xlim(lmin, lmax) ## 5.1. data Cl_obs = Cl_fid['BB'] + Cl_noise dof = (2 * ell + 1) * fsky YY = Cl_xF['YY'] tr_SigmaYY = np.einsum('ij, lji -> l', res.Sigma, YY) ## 5.2. modeling def cosmo_likelihood(r_): # S16, Appendix C Cl_model = Cl_fid['BlBl'] * Alens + Cl_fid['BuBu'] * r_ + Cl_noise dof_over_Cl = dof / Cl_model ## Eq. C3 U = np.linalg.inv(res.Sigma_inv + np.dot(YY.T, dof_over_Cl)) ## Eq. C9 first_row = np.sum( dof_over_Cl * (Cl_obs * (1 - np.einsum('ij, lji -> l', U, YY) / Cl_model) + tr_SigmaYY)) second_row = -np.einsum('l, m, ij, mjk, kf, lfi', dof_over_Cl, dof_over_Cl, U, YY, res.Sigma, YY) trCinvC = first_row + second_row ## Eq. C10 first_row = np.sum(dof_over_Cl * (Cl_xF['yy'] + 2 * Cl_xF['yz'])) ### Cyclicity + traspose of scalar + grouping terms -> trace becomes ### Yy_ell^T U (Yy + 2 Yz)_ell' trace = np.einsum('li, ij, mj -> lm', Cl_xF['Yy'], U, Cl_xF['Yy'] + 2 * Cl_xF['Yz']) second_row = -_utmv(dof_over_Cl, trace, dof_over_Cl) trECinvC = first_row + second_row ## Eq. C12 logdetC = np.sum(dof * np.log(Cl_model)) - np.log(np.linalg.det(U)) # Cl_hat = Cl_obs + tr_SigmaYY ## Bringing things together return trCinvC + trECinvC + logdetC # Likelihood maximization r_grid = np.logspace(-5, 0, num=500) logL = np.array([cosmo_likelihood(r_loc) for r_loc in r_grid]) ind_r_min = np.argmin(logL) r0 = r_grid[ind_r_min] if ind_r_min == 0: bound_0 = 0.0 bound_1 = r_grid[1] # pl.figure() # pl.semilogx(r_grid, logL, 'r-') # pl.show() elif ind_r_min == len(r_grid) - 1: bound_0 = r_grid[-2] bound_1 = 1.0 # pl.figure() # pl.semilogx(r_grid, logL, 'r-') # pl.show() else: bound_0 = r_grid[ind_r_min - 1] bound_1 = r_grid[ind_r_min + 1] print('bounds on r = ', bound_0, ' / ', bound_1) print('starting point = ', r0) res_Lr = sp.optimize.minimize(cosmo_likelihood, [r0], bounds=[(bound_0, bound_1)], **minimize_kwargs) print(' ===>> fitted r = ', res_Lr['x']) print('======= ESTIMATION OF SIGMA(R) =======') def sigma_r_computation_from_logL(r_loc): THRESHOLD = 1.00 # THRESHOLD = 2.30 when two fitted parameters delta = np.abs(cosmo_likelihood(r_loc) - res_Lr['fun'] - THRESHOLD) # print r_loc, cosmo_likelihood(r_loc), res_Lr['fun'] return delta if res_Lr['x'] != 0.0: sr_grid = np.logspace(np.log10(res_Lr['x']), 0, num=25) else: sr_grid = np.logspace(-5, 0, num=25) slogL = np.array( [sigma_r_computation_from_logL(sr_loc) for sr_loc in sr_grid]) ind_sr_min = np.argmin(slogL) sr0 = sr_grid[ind_sr_min] print('ind_sr_min = ', ind_sr_min) print('sr_grid[ind_sr_min-1] = ', sr_grid[ind_sr_min - 1]) print('sr_grid[ind_sr_min+1] = ', sr_grid[ind_sr_min + 1]) print('sr_grid = ', sr_grid) if ind_sr_min == 0: print('case # 1') bound_0 = res_Lr['x'] bound_1 = sr_grid[1] elif ind_sr_min == len(sr_grid) - 1: print('case # 2') bound_0 = sr_grid[-2] bound_1 = 1.0 else: print('case # 3') bound_0 = sr_grid[ind_sr_min - 1] bound_1 = sr_grid[ind_sr_min + 1] print('bounds on sigma(r) = ', bound_0, ' / ', bound_1) print('starting point = ', sr0) res_sr = sp.optimize.minimize( sigma_r_computation_from_logL, sr0, bounds=[(bound_0.item(), bound_1.item())], # item required for test to pass but reason unclear. sr_grid has # extra dimension? **minimize_kwargs) print(' ===>> sigma(r) = ', res_sr['x'] - res_Lr['x']) res.cosmo_params = {} res.cosmo_params['r'] = (res_Lr['x'], res_sr['x'] - res_Lr['x']) ############################################################################### # 6. Produce figures if make_figure: print('======= GRIDDING COSMO LIKELIHOOD =======') r_grid = np.logspace(-4, -1, num=500) logL = np.array([cosmo_likelihood(r_loc) for r_loc in r_grid]) chi2 = logL - np.min(logL) ax0.semilogx(r_grid, np.exp(-chi2), color='DarkOrange', linestyle='-', linewidth=2.0, alpha=0.8) ax0.axvline(x=r, color='k', linestyle='--') ax0.set_ylabel(r'$\mathcal{L}(r)$', fontsize=20) ax0.set_xlabel(r'tensor-to-scalar ratio $r$', fontsize=20) pl.show() return res
def read_kappa_input(nside=256): kappa_input = fits.open('kappa_input_gaussian.fits')[1].data.I.ravel() #kappa_input = fits.open('kappa_input_noiseless.fits')[1].data.I.ravel() alm_input = hp.map2alm(kappa_input, lmax=3*nside-1) kappa_input = hp.alm2map(alm_input, nside=nside) return kappa_input