Ejemplo n.º 1
0
    def test_pixwin_base(self):
        # Base case
        nsides = [2**p for p in np.arange(1, 14)]
        [hp.pixwin(nside) for nside in nsides]

        # Test invalid nside
        with self.assertRaises(ValueError):
            hp.pixwin(15)
Ejemplo n.º 2
0
    def test_pixwin_lmax(self):
        nside = 128
        pixwin = hp.pixwin(nside, lmax=None)
        self.assertEqual(len(pixwin), 3 * nside)

        lmax = 200
        pixwin = hp.pixwin(nside, lmax=lmax)
        self.assertEqual(len(pixwin)-1, lmax)
Ejemplo n.º 3
0
    def test_pixwin_lmax(self):
        nside = 128
        pixwin = hp.pixwin(nside, lmax=None)
        self.assertEqual(len(pixwin), 3 * nside)

        lmax = 200
        pixwin = hp.pixwin(nside, lmax=lmax)
        self.assertEqual(len(pixwin) - 1, lmax)
Ejemplo n.º 4
0
    def test_pixwin_base(self):
        # Base case
        nsides = [2 ** p for p in np.arange(1, 14)]
        [hp.pixwin(nside) for nside in nsides]

        # Test invalid nside
        with self.assertRaises(ValueError):
            hp.pixwin(15)
def run_propag():
    """
    Follows the SMICA propagation code to combine maps with set of weights.
    Only runs for the chosen bins and up to the max value of bins
    """
    CMB = dict()
    CMB["TQU"] = dict()
    almT, almE, almB = dict(), dict(), dict()
    lmaxbin = int(bins[-1][1]+1)

    W = io.load_data(io.fh.weight_smica_path_name)

    # full maps
    maps = io.load_plamap(csu.cf, field=(0,1,2), nside_out=csu.nside_out)
    maps = trsf_m.process_all(maps)

    for freq in csu.PLANCKMAPFREQ_f:
        ns = csu.nside_out[0] if int(freq) < 100 else csu.nside_out[1]
        alms = pw.map2alm_spin(maps[freq], hp.ud_grade(pmask[freq], nside_out=ns), 2, lmaxbin-1) # full sky QU->EB
        # almT[det] = alms[0]
        almE[freq] = alms[0]
        almB[freq] = alms[1]

    nalm = int((lmaxbin)*(lmaxbin-1+2)/2)  
    # combalmT = np.zeros((nalm), dtype=np.complex128)
    combalmE = np.zeros((nalm), dtype=np.complex128)
    combalmB = np.zeros((nalm), dtype=np.complex128)
    beamf = io.load_beamf(freqcomb=csu.freqcomb)

    xnew = np.arange(0,lmaxbin,1)
    for it, det in enumerate(csu.PLANCKMAPFREQ): #weights do not depend on freqfilter, but almE/B do
        if det in csu.PLANCKMAPFREQ_f:
            ns = csu.nside_out[0] if int(det) < 100 else csu.nside_out[1]
            W_Einterp = interpolate.interp1d(np.mean(bins, axis=1), W[1,it,:], bounds_error = False, fill_value='extrapolate')
            #TODO switch to W[2,:] once BB-weights are correctly calculated
            W_Binterp = interpolate.interp1d(np.mean(bins, axis=1), W[1,it,:], bounds_error = False, fill_value='extrapolate')

            # combalmT += hp.almxfl(almT[name], np.squeeze(W[0,m,:]))
            LHFI = "LFI" if int(det)<100 else "HFI"
            combalmE += hp.almxfl(hp.almxfl(almE[det],1/beamf[str(det)+'-'+str(det)][LHFI][1].data.field(1)[:lmaxbin]), np.squeeze(W_Einterp(xnew)))
            combalmE = hp.almxfl(combalmE, 1/hp.pixwin(ns, pol=True)[0][:lmaxbin])
            combalmB += hp.almxfl(hp.almxfl(almB[det],1/beamf[str(det)+'-'+str(det)][LHFI][1].data.field(2)[:lmaxbin]), np.squeeze(W_Binterp(xnew)))
            combalmB = hp.almxfl(combalmB, 1/hp.pixwin(ns, pol=True)[1][:lmaxbin])

    CMB["TQU"]['out'] = hp.alm2map([np.zeros_like(combalmE), combalmE, combalmB], csu.nside_out[1])
    io.save_data(CMB["TQU"]['out'], io.fh.cmbmap_smica_path_name)
    smica_C_lmin_unsc = np.array(ps.map2cl_spin(qumap=CMB["TQU"]['out'][1:3], spin=2, mask=pmask['100'], lmax=lmaxbin-1,
        lmax_mask=lmaxbin*2))*1e12 #maps are different scale than processed powerspectra from this' package pipeline, thus *1e12
    io.save_data(smica_C_lmin_unsc, io.fh.clmin_smica_path_name)
Ejemplo n.º 6
0
    def apply_ivf(self, dets, tmaps):
        assert(self.lmax == 1000)

        n_inv_filts = []
        for det in dets:
            mask_t = qcinv.util.load_map(self.mask_t)

            bl  = dmc.get_bl(self.sim_lib.year, det)[0:self.lmax+1]
            pxw = hp.pixwin( self.sim_lib.nside )[0:self.lmax+1]

            # qcinv filtering for temperature
            dcf = self.lib_dir + "/dense_cache_det_" + det + ".pk"
            #                  id         preconditioners                 lmax    nside     im      em            tr                      cache
            chain_descr = [ [  2, ["split(dense("+dcf+"), 64, diag_cl)"],  256,   128,       3,     0.0,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()],
                            [  1, ["split(stage(2), 256, diag_cl)"],       512,   256,       3,     0.0,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()],
                            [  0, ["split(stage(1), 512, diag_cl)"],      1000,   512,  np.inf,  1.0e-6,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()] ]

            ninv = ( hp.read_map( dmc.get_fname_imap(self.sim_lib.year, det, self.sim_lib.forered), hdu=1, field=1 ) /
                     dmc.sigma0[(self.sim_lib.year, self.sim_lib.forered, 'T')][det]**2 / 1e6 * mask_t )
            n_inv_filt = qcinv.opfilt_tt.alm_filter_ninv( ninv, bl*pxw, marge_monopole=True, marge_dipole=True, marge_maps=[] )
            n_inv_filts.append( n_inv_filt )
        n_inv_filts = qcinv.opfilt_tt_multi_simple.alm_filter_ninv_filts( n_inv_filts, degrade_single=True )

        chain = qcinv.multigrid.multigrid_chain( qcinv.opfilt_tt_multi_simple, chain_descr, self.cl, n_inv_filts )

        tlm = np.zeros( qcinv.util_alm.lmax2nlm(self.lmax), dtype=np.complex )
        chain.solve( tlm, tmaps )

        return tlm
Ejemplo n.º 7
0
def get_maps_cl(frec, fconv=None, lmin=20, delta_ell=40, apodization_degrees=5.):
    mrec, resid, seenmap = get_maps_residuals(frec, fconv=fconv)
    sh = np.shape(mrec)
    print(sh, np.shape(resid))
    nbsub = sh[1]
    ns = hp.npix2nside(sh[2])

    from qubic import apodize_mask
    mymask = apodize_mask(seenmap, apodization_degrees)

    # Create XPol object
    from qubic import Xpol
    lmax = 2 * ns
    xpol = Xpol(mymask, lmin, lmax, delta_ell)
    ell_binned = xpol.ell_binned
    nbins = len(ell_binned)
    # Pixel window function
    pw = hp.pixwin(ns)
    pwb = xpol.bin_spectra(pw[:lmax + 1])

    # Calculate all crosses and auto
    m_autos = np.zeros((nbsub, 6, nbins))
    s_autos = np.zeros((nbsub, 6, nbins))
    m_cross = np.zeros((nbsub, 6, nbins))
    s_cross = np.zeros((nbsub, 6, nbins))
    fact = ell_binned * (ell_binned + 1) / 2. / np.pi
    for isub in range(nbsub):
        m_autos[isub, :, :], s_autos[isub, :, :], m_cross[isub, :, :], s_cross[isub, :, :] = \
            allcross_par(xpol, mrec[:, isub, :, :], silent=False, verbose=0)

    return mrec, resid, seenmap, ell_binned, m_autos * fact / pwb ** 2, \
           s_autos * fact / pwb ** 2, m_cross * fact / pwb ** 2, s_cross * fact / pwb ** 2
Ejemplo n.º 8
0
    def apply_ivf(self, det, tmap, pmap):
        assert(self.lmax == 1000)

        mask_t = qcinv.util.load_map(self.mask_t)
        mask_p = qcinv.util.load_map(self.mask_p)

        bl  = dmc.get_bl(self.sim_lib.year, det)[0:self.lmax+1]
        pxw = hp.pixwin( self.sim_lib.nside )[0:self.lmax+1]

        # qcinv filtering for temperature
        dcf = self.lib_dir + "/dense_cache_det_" + det + ".pk"
        #                  id         preconditioners                 lmax    nside     im      em            tr                      cache
        chain_descr = [ [  2, ["split(dense("+dcf+"), 64, diag_cl)"],  256,   128,       3,     0.0,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()],
                        [  1, ["split(stage(2), 256, diag_cl)"],       512,   256,       3,     0.0,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()],
                        [  0, ["split(stage(1), 512, diag_cl)"],      1000,   512,  np.inf,  1.0e-6,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()] ]

        ninv = ( hp.read_map( dmc.get_fname_iqumap(self.sim_lib.year, det, self.sim_lib.forered), hdu=1, field=3 ) /
                 dmc.sigma0[(self.sim_lib.year, self.sim_lib.forered, 'T')][det]**2 / 1e6 * mask_t ) 
        n_inv_filt = qcinv.opfilt_tt.alm_filter_ninv( ninv, bl*pxw, marge_monopole=True, marge_dipole=True, marge_maps=[] )
        chain = qcinv.multigrid.multigrid_chain( qcinv.opfilt_tt, chain_descr, self.cl, n_inv_filt )

        tlm = np.zeros( qcinv.util_alm.lmax2nlm(self.lmax), dtype=np.complex )
        chain.solve( tlm, tmap )

        # simple filtering for polarization.
        elm, blm = hp.map2alm_spin( (pmap.real * mask_p, pmap.imag * mask_p), 2, lmax=self.lmax )
        ftl, fel, fbl = self.get_ftebl(det)
        hp.almxfl( elm, fel / bl / pxw, inplace=True )
        hp.almxfl( blm, fbl / bl / pxw, inplace=True )

        return tlm, elm, blm
Ejemplo n.º 9
0
def masked_cl(ellmax, mask_name, mask_fn, outfits_root, final_maps):
    #Masked spectra
    print "Calculating masked C_l"
    mask = hp.read_map(mask_fn)  #0 where holes #RING ordering
    f_sky = np.sum(mask) / len(mask)
    print "f_sky =", f_sky
    masked_maps = [final_maps[0] * mask,
                   final_maps[1] * mask]  #(Q*mask,U*mask)
    T_map = [
        np.zeros_like(final_maps[0]),
    ]
    masked_cls = hp.anafast(T_map + masked_maps,
                            lmax=ellmax - 1)  #(TT,EE,BB,TE,EB,TB)
    pixrecip = np.concatenate(
        (np.ones(2),
         np.reciprocal(
             hp.pixwin(
                 hp.get_nside(masked_maps[0]),
                 pol=True)[1][2:ellmax])))  #P pixwin #Not defined for l < 2
    clscode = ['EE', 'BB', 'EB']
    clsidx = [1, 2, 4]
    for i in xrange(len(clscode)):
        cl_outfits = outfits_root + '_' + clscode[
            i] + 'cls_' + mask_name + '.fits'
        hp.write_cl(cl_outfits,
                    masked_cls[clsidx[i]] * pixrecip * pixrecip / f_sky)

    return 0
Ejemplo n.º 10
0
def get_kbeam(qid,
              modlmap,
              sanitize=False,
              version=None,
              planck_pixwin=False,
              **kwargs):
    dmodel = sints.arrays(qid, 'data_model')
    season = sints.arrays(qid, 'season')
    region = sints.arrays(qid, 'region')
    array = sints.arrays(qid, 'array')
    freq = sints.arrays(qid, 'freq')
    dm = sints.models[dmodel]()
    gfreq = array + "_" + freq if not (is_planck(qid)) else freq
    if planck_pixwin and (qid in [
            'p01', 'p02', 'p03', 'p04', 'p05', 'p06', 'p07', 'p08'
    ]):
        nside = get_nside(qid)
        pixwin = hp.pixwin(nside=nside, pol=False)
        ls = np.arange(len(pixwin))
        assert pixwin.ndim == 1
        assert ls.size in [6144, 3072]
        pwin = maps.interp(ls, pixwin)(modlmap)
    else:
        pwin = 1.
    return dm.get_beam(modlmap,
                       season=season,
                       patch=region,
                       array=gfreq,
                       kind='normalized',
                       sanitize=sanitize,
                       version=version,
                       **kwargs) * pwin
Ejemplo n.º 11
0
def worker_power(map, lmax):
    logger = logging.getLogger(__name__)

    factor = 1 - np.sum(map == hp.UNSEEN) / len(map)

    logger.info("processing map ({:.0f} deg^2)".format(4*factor*np.pi*(180/np.pi)**2))

    return hp.anafast(map, lmax=lmax) / hp.pixwin(hp.npix2nside(len(map)))[:lmax + 1] ** 2 / factor
Ejemplo n.º 12
0
def compute_ds_dcb_line_par(map,mask,ellmin,ellmax,fwhmrad,nthreads):
    npix=np.size(np.where(mask))
    ellbins=ellmin.size
    ellval=(ellmin+ellmax)/2
    print('    Calculating dS/dCb')
    pixwin=hp.pixwin(hp.npix2nside(len(map)))
    maxell=np.max(ellmax)
    ll=np.arange(int(maxell)+1)
    bl=np.exp(-0.5*ll**2*(fwhmrad/2.35)**2)
    
    nside=np.sqrt(map.size/12)
    iprings=np.arange(map.size)
    vecs=hp.pix2vec(int(nside),iprings[mask])
    cosangles=np.dot(np.transpose(vecs),vecs)

    nshots=npix//nthreads+1
    ntot=nshots*nthreads
    indices=np.arange(ntot)
    indices[indices>npix-1]=npix-1
    lines=np.reshape(indices,(nshots,nthreads))
    
    ds_dcb=np.zeros((ellbins,npix,npix))

    for num in np.arange(nshots):
        # initiate multithreading
        tasks=multiprocessing.JoinableQueue()
        results = multiprocessing.Queue()
        # start consumers
        num_consumers = nthreads
        #print 'Creating %d consumers' % num_consumers
        consumers = [ Consumer(tasks, results)
                for i in xrange(num_consumers) ]
        for w in consumers:
            w.start()
        # Enqueue jobs
        num_jobs = nthreads
        for i in np.arange(num_jobs):
            #print('Calling task ',lines[num,i])
            tasks.put(Task(cosangles[lines[num,i],:],lines[num,i],ll,bl,pixwin,ellmin,ellmax,ellval))
        # poison them when finished
        for i in np.arange(num_jobs):
            #print 'Killing Task %d ' % i
            tasks.put(None)
            
        #print('****** Now ready to join tasks ******')
        tasks.join()
        #print('###### Tasks were joined ######')

        while num_jobs:
            #print('Getting result for task %d' % num_jobs)
            result = results.get()
            bla=result[0]
            num=result[1]
            ds_dcb[:,num,num:]=bla[:,num:]
            ds_dcb[:,num:,num]=bla[:,num:]
            num_jobs -= 1
    
    return(ds_dcb)
Ejemplo n.º 13
0
    def get_pixwin_correction(self, nside):
        pw = hp.pixwin(nside, pol=True, lmax=self.lmax)
        pw = [pw[0][:self.lmax + 1], pw[1][:self.lmax + 1]]

        ell_binned, b = self.get_binning(nside)
        pwb = 2 * np.pi / (ell_binned *
                           (ell_binned + 1)) * b.bin_cell(np.array(pw))

        return pwb
Ejemplo n.º 14
0
def get_ftl_eff( lmax, year, nside, det, forered, cl, mask_t ):
    noiseT_uK_arcmin = dmc.get_nlev_t_uK_arcmin(year, det, forered, mask_t)

    bl  = dmc.get_bl( year, det)[0:lmax+1]
    pxw = hp.pixwin( nside )[0:lmax+1]

    ftl = 1.0 / (cl.cltt[0:lmax+1] + (noiseT_uK_arcmin * np.pi/180./60.)**2 / (bl * pxw)**2); ftl[0:2] = 0.0

    return ftl
Ejemplo n.º 15
0
    def get_pixwin_correction(self, nside):
        """Return the binned pixel window function multiplied by 2pi/(l(l+1))
        for temperature and polarization """
        pw = list(hp.pixwin(nside, pol=True, lmax=self.lmax))

        ell_binned, b = self.get_binning(nside)
        pwb = 2 * np.pi / (ell_binned * (ell_binned + 1)) * b.bin_cell(np.array(pw))

        return pwb
Ejemplo n.º 16
0
def build_cov(cl,
              nside,
              mask=None,
              tree_depth=0,
              lmax=None,
              apply_pixwin=False,
              ninterp=10000,
              log=False,
              shift=None):
    tree_depth = 2**(tree_depth)

    if mask is None:
        mask = np.ones(hp.nside2npix(nside), dtype=bool)

    if lmax is not None and lmax > len(cl) - 1:
        lmax = len(cl) - 1

        cl = cl[:lmax + 1]

    if apply_pixwin:
        pw = hp.pixwin(nside * tree_depth, lmax=lmax)

        cl = cl[:len(pw)] * (pw**2)

    npix = int(mask.sum())
    mask_inds = hp.ring2nest(nside, np.arange(hp.nside2npix(nside))[mask])

    thetas = np.linspace(0, np.pi, ninterp)
    xis = cl2xi_theta(cl, thetas)

    exe_path = os.path.join(os.path.dirname(__file__), 'healcov')
    proc = subprocess.Popen(exe_path,
                            stdin=subprocess.PIPE,
                            stdout=subprocess.PIPE)

    proc.stdin.write(nside.to_bytes(8, 'little'))
    proc.stdin.write(npix.to_bytes(8, 'little'))
    proc.stdin.write(mask_inds.tobytes())
    proc.stdin.write(tree_depth.to_bytes(8, 'little'))
    proc.stdin.write(ninterp.to_bytes(8, 'little'))
    proc.stdin.write(thetas.tobytes())
    proc.stdin.write(xis.tobytes())
    proc.stdin.close()

    cov = np.frombuffer(proc.stdout.read()).reshape([npix, npix])

    info = proc.wait()

    if info != 0:
        raise Exception()

    if log is True:
        cov = np.log(cov / (shift**2) + 1)

    return cov
Ejemplo n.º 17
0
    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
Ejemplo n.º 18
0
def get_ftebl_eff( lmax, year, nside, det, forered, cl, mask_t, mask_p ):
    noiseT_uK_arcmin, noiseP_uK_arcmin = dmc.get_nlev_tp_uK_arcmin(year, det, forered, mask_t, mask_p)

    bl  = dmc.get_bl( year, det)[0:lmax+1]
    pxw = hp.pixwin( nside )[0:lmax+1]

    ftl = 1.0 / (cl.cltt[0:lmax+1] + (noiseT_uK_arcmin * np.pi/180./60.)**2 / (bl * pxw)**2); ftl[0:2] = 0.0
    fel = 1.0 / (cl.clee[0:lmax+1] + (noiseP_uK_arcmin * np.pi/180./60.)**2 / (bl * pxw)**2); fel[0:2] = 0.0
    fbl = 1.0 / (cl.clbb[0:lmax+1] + (noiseP_uK_arcmin * np.pi/180./60.)**2 / (bl * pxw)**2); fbl[0:2] = 0.0

    return ftl, fel, fbl
Ejemplo n.º 19
0
def apply_pixwin(data: np.array, freqcomb, nside) -> Dict:
    """Applies Pixel Windowfunction with nside specified
    Args:
        data (Dict): powerspectra with spectrum and frequency-combinations in the columns
        
    Returns:
        Dict: Pixel Windowfunction applied Powerspectra with spectrum and frequency-combinations in the columns
    """
    for fidx, freql in enumerate(data):
        for sidx, specl in enumerate(freql):
            lmaxp1 = data.shape[-1]
            freqc = freqcomb[fidx]
            if int(freqc.split("-")[0]) < 100:
                data[fidx, sidx] /= hp.pixwin(nside[0], lmax=lmaxp1 - 1)
            else:
                data[fidx, sidx] /= hp.pixwin(nside[1], lmax=lmaxp1 - 1)
            if int(freqc.split("-")[1]) < 100:
                data[fidx, sidx] /= hp.pixwin(nside[0], lmax=lmaxp1 - 1)
            else:
                data[fidx, sidx] /= hp.pixwin(nside[1], lmax=lmaxp1 - 1)
    return data
Ejemplo n.º 20
0
 def get_pixel_window_function(self, nside, lmax, pol=True):
     """
     Get the pixel window function assigned to self.spectra for the given nside
     """
     pixel_window_np = hp.pixwin(nside=nside, pol=pol)
     if pol:
         self.spectra['TT'] = pixel_window_np[0]
         self.spectra['EE'] = pixel_window_np[1]
         self.spectra['BB'] = pixel_window_np[1]
         self.spectra['TE'] = pixel_window_np[1]
     else:
         self.spectra['TT'] = pixel_window_np
     self.truncate(after=lmax)
Ejemplo n.º 21
0
    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
Ejemplo n.º 22
0
def load_chan_realization_alms(chan_fmt, chani, reali, lmax):
    '''
    Loads a channel and computes the spherical harmonic expansion of the map.

    For polarized channels (nu < 545 GHz), returns a 3-tuple of (T, E, B)
    alms, while for unpolarized channels (545 and 857 GHz) it returns T. All
    alms are in healpix order.

    Already adjusts for the pixel window function.
    '''
    fname = chan_fmt.format(chan=planck_freqs[chani], real=reali)
    if chani < 7:
        maps = 1e6*hp.read_map(fname,
                               field=(0, 1, 2))
        nside = hp.npix2nside(maps[0].size)

        alms = hp.map2alm(maps, pol=True, lmax=lmax)

        # First adjust T by pwT, then E&B by pwE
        pwT, pwE = hp.pixwin(nside=nside, pol=True, lmax=lmax)
        alms[0] = hp.almxfl(alms[0], 1 / pwT)

        # Set the pwE=0 \ells to 0
        pol_adj = np.zeros_like(pwE)
        pol_adj[pwE != 0] = 1 / pwE[pwE != 0]
        alms[1] = hp.almxfl(alms[1], pol_adj)
        alms[2] = hp.almxfl(alms[2], pol_adj)

        return alms

    factor = 1e6 / cfact_545_857[chani-7]
    map = factor * hp.read_map(fname)
    nside = hp.npix2nside(map.size)
    alms = np.zeros((3, hp.Alm.getsize(lmax=lmax)), dtype=np.complex)
    alms[0] = hp.map2alm(map, pol=False, lmax=lmax)
    alms[0] = hp.almxfl(alms[0], 1 / hp.pixwin(nside=nside, lmax=lmax))

    return alms
Ejemplo n.º 23
0
def gen_lgmca_like(lgmca_file, cov_file,
                   lmin=70, lmax=2000, delta_ell=30):
    # Load covariance
    cov = np.loadtxt(cov_file)

    # Add l (l + 1) factor (i.e. convert cl -> dl)
    ells = np.arange(lmax + 1)
    ll1 = ells * (ells + 1) / (2 * np.pi)

    # Load data vector
    dls = hp.read_cl(lgmca_file)[:lmax + 1] / (getbeam(5, lmax) * hp.pixwin(2048, lmax=lmax))**2

    # 1e12 is K^2 -> \mu K^2
    return bare_gen_like(1e12 * ll1 * dls, cov, lmin=lmin, lmax=lmax, delta_ell=delta_ell)
Ejemplo n.º 24
0
    def apply_ivf(self, det, tmap, pmap):
        mask_t = qcinv.util.load_map(self.mask_t)
        mask_p = qcinv.util.load_map(self.mask_p)

        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 )
        elm, blm = hp.map2alm_spin( (pmap.real * mask_p, pmap.imag * mask_p), 2, lmax=self.lmax )

        hp.almxfl( tlm, self.ftl / bl / pxw, inplace=True )
        hp.almxfl( elm, self.fel / bl / pxw, inplace=True )
        hp.almxfl( blm, self.fbl / bl / pxw, inplace=True )
    
        return tlm, elm, blm
Ejemplo n.º 25
0
def get_alm_maps(pixel_maps,
                 fwhms,
                 resol_correction=False,
                 ref_fwhm=0,
                 pixwin_correction=False,
                 verbose=False):
    """
    Compute alm maps from pixel maps and format them for FgBuster.
    """
    sh = np.shape(pixel_maps)
    nside = hp.npix2nside(sh[2])
    n = sh[0]
    lmax = 2 * nside + 1
    ell = np.arange(start=0, stop=lmax + 1)

    ref_sigma_rad = np.deg2rad(ref_fwhm) / 2.355
    #ref_fl = np.exp(- 0.5 * np.square(ref_sigma_rad * ell))
    ref_fl = hp.gauss_beam(np.deg2rad(ref_fwhm), lmax=lmax)

    if verbose:
        print('In get_alm_maps: FWHM = ', fwhms)
    beam_sigmas_rad = np.deg2rad(fwhms) / (2 * np.sqrt(2 * np.log(2)))
    pixwin = hp.pixwin(nside,
                       lmax=lmax) if pixwin_correction else np.ones(lmax + 1)

    # compute maps
    #figure()
    alm_maps = None
    for f in range(n):
        alms = hp.map2alm(pixel_maps[f], lmax=lmax, pol=True)
        correction = None
        if f == 0:
            sh = np.shape(alms)
            alm_maps = np.empty((n, sh[0], 2 * sh[1]))
        if resol_correction:
            print('Applying Resol Correction')
            #gauss_fl = np.exp(- 0.5 * np.square(beam_sigmas_rad[f] * ell))
            gauss_fl = hp.gauss_beam(np.deg2rad(fwhms[f]), lmax=lmax)
            correction = ref_fl / gauss_fl / pixwin
            #plot(correction, label='freq {}'.format(f))
        else:
            print('No Resol Correction applied')
        for i, t in enumerate(alms):
            alm_maps[f, i] = format_alms(
                hp.almxfl(t, correction) if resol_correction else t)
    #legend()
    #title('Bl ratio in get_alm_maps')
    return alm_maps
Ejemplo n.º 26
0
def get_xpol(seenmap, ns, lmin=20, delta_ell=20, apodization_degrees=5.):
    """
    Returns a Xpoll object to get spectra, the bin used and the pixel window function.
    """
    # Create a mask
    mymask = apodize_mask(seenmap, apodization_degrees)

    # Create XPol object
    lmax = 2 * ns
    xpol = Xpol(mymask, lmin, lmax, delta_ell)
    ell_binned = xpol.ell_binned
    # Pixel window function
    pw = hp.pixwin(ns)
    pwb = xpol.bin_spectra(pw[:lmax + 1])

    return xpol, ell_binned, pwb
Ejemplo n.º 27
0
    def get_ftl(self, detstr):
        dets = self.detstr2dets(detstr)

        clnn    = np.zeros(self.lmax+1)
        for det in dets:
            noiseT_uK_arcmin = dmc.get_nlev_t_uK_arcmin(self.sim_lib.year, det, self.sim_lib.forered, qcinv.util.load_map(self.mask_t))

            bl  = dmc.get_bl( self.sim_lib.year, det)[0:self.lmax+1]
            pxw = hp.pixwin( self.sim_lib.nside )[0:self.lmax+1]

            clnn += (bl * pxw)**2 / (noiseT_uK_arcmin * np.pi/180./60.)**2
        clnn = 1./clnn

        ftl = 1.0 / (self.cl.cltt[0:self.lmax+1] + clnn); ftl[0:2] = 0.0

        return ftl
Ejemplo n.º 28
0
    def apply_ivf(self, det, tmap, pmap):
        mask_t = qcinv.util.load_map(self.mask_t)
        mask_p = qcinv.util.load_map(self.mask_p)

        tlm = hp.map2alm( tmap * mask_t, lmax=self.lmax, iter=0, regression=False )
        elm, blm = hp.map2alm_spin( (pmap.real * mask_p, pmap.imag * mask_p), 2, lmax=self.lmax )

        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, fel, fbl = self.get_ftebl(det)

        hp.almxfl( tlm, ftl / bl / pxw, inplace=True )
        hp.almxfl( elm, fel / bl / pxw, inplace=True )
        hp.almxfl( blm, fbl / bl / pxw, inplace=True )

        return tlm, elm, blm
Ejemplo n.º 29
0
def FilterMap(pixmap, freq, mask=None, lmax=None, pixelwindow=False):
    if mask is None:
        mask = np.ones_like(pixmap)
    else:
        assert hp.isnpixok(mask.size)
    Fl = GetFl(pixmap,freq, mask=mask, lmax=lmax)
    alm_fname='alm_%s.fits'%freq
    if not os.path.exists(alm_fname):
	print "computing alms"
	alm = hp.map2alm(pixmap, lmax=lmax)
	hp.write_alm(alm_fname,alm)
    else:
	print "reading alms",alm_fname
	alm = hp.read_alm(alm_fname)
    if pixelwindow:
	print "Correcting alms for pixelwindow"
        pl=hp.pixwin(hp.npix2nside(pixmap.size))[:lmax+1]
    else: pl=np.ones(len(Fl))
    return hp.alm2map(hp.almxfl(alm, Fl/pl), hp.npix2nside(pixmap.size), lmax=lmax), Fl
def GetSpectra(map1, mask, lmax, map2=None, pixwin=True, beam=None, flat=True):
    if pixwin:
        pl = hp.pixwin(hp.npix2nside(len(map1)))[:lmax + 1]
    else:
        pl = np.ones(lmax + 1)
    if beam is not None:
        bl = hp.gauss_beam(np.radians(beam / 60.), lmax=lmax)
    else:
        bl = np.ones(lmax + 1)

    fsky = np.mean(mask**2)

    cl = hp.anafast(map1 * mask, map2=map2, lmax=lmax)

    if flat:
        l = np.arange(lmax + 1)
        fact = l * (l + 1) / 2. / np.pi
    else:
        fact = 1.

    return cl / fsky / bl**2 / pl**2 * fact
Ejemplo n.º 31
0
    def simulate(self, det, idx):
        assert(det == '')
        
        tlm = self.sim_teblm_cmb.get_sim_tlm(idx)
        elm = self.sim_teblm_cmb.get_sim_elm(idx)
        blm = self.sim_teblm_cmb.get_sim_blm(idx)

        beam = self.bl[0:self.lmax+1] * hp.pixwin(self.nside)[0:self.lmax+1]
        hp.almxfl(tlm, beam, inplace=True)
        hp.almxfl(elm, beam, inplace=True)
        hp.almxfl(blm, beam, inplace=True)
        
        tmap = hp.alm2map(tlm, self.nside)
        qmap, umap = hp.alm2map_spin( (elm, blm), self.nside, 2, lmax=self.lmax )

        npix = 12*self.nside**2
        tmap += np.random.standard_normal(npix) * (self.noiseT_uK_arcmin * np.sqrt(npix / 4. / np.pi) * np.pi / 180. / 60.)
        qmap += np.random.standard_normal(npix) * (self.noiseP_uK_arcmin * np.sqrt(npix / 4. / np.pi) * np.pi / 180. / 60.)
        umap += np.random.standard_normal(npix) * (self.noiseP_uK_arcmin * np.sqrt(npix / 4. / np.pi) * np.pi / 180. / 60.)

        return tmap, qmap + 1.j*umap
Ejemplo n.º 32
0
def analworker(i):
    print "This is analysis worker starting for map", i + 1, "/", nmaps
    QU_maps = hp.read_map(fits[i], field=(1, 2))  #(Q,U)
    pixrecip = np.concatenate((np.ones(2),
                               np.reciprocal(
                                   hp.pixwin(hp.get_nside(QU_maps[0]),
                                             pol=True)[1][2:smoothing_lmax])
                               ))  #P pixwin #Not defined for l < 2
    pm_alms = hp.map2alm_spin(QU_maps, spin, lmax=smoothing_lmax - 1)
    del QU_maps
    hp.almxfl(pm_alms[0], pixrecip, inplace=True)  #Correcting for pixwin
    hp.almxfl(pm_alms[1], pixrecip, inplace=True)  #Correcting for pixwin

    #Reorder to S2LET alms
    pm_alms[0] = ps.lm_hp2lm(pm_alms[0], smoothing_lmax)
    pm_alms[1] = ps.lm_hp2lm(pm_alms[1], smoothing_lmax)

    P_alms = -1. * pm_alms[0] - 1.j * pm_alms[1]  #CHECK THIS IS CORRECT!
    del pm_alms

    wav_maps, scal_maps = ps.analysis_lm2wav_manualtiling(
        P_alms, smoothing_lmax, ndir, spin, scal_tiles, wav_tiles.T.ravel(),
        scal_bandlims, wav_bandlims)
    del P_alms
    np.save(scal_outfits[i], scal_maps)
    del scal_maps

    #Splitting up output wavelet maps
    offset = 0
    for j in xrange(jmax + 1):
        for n in xrange(ndir):
            bandlim = wav_bandlims[j]
            nelem = bandlim * (2. * bandlim - 1.)
            wav_outfits = wav_outfits_root[i] + '_j' + str(j) + '_n' + str(
                n + 1) + '.npy'
            np.save(wav_outfits, wav_maps[offset:offset + nelem])
            offset += nelem
    del wav_maps

    return 0
Ejemplo n.º 33
0
def estimate_cl(sky_map, lmax, binary_mask=None, beam_fwhm=0.0, pixwin=False):
    """
    Estimates the TT, EE, BB and TE auto/cross power spectrum.
    The sky map(s) will be masked by the binary mask provided.
    beam_fwhm input is in arcmins. It is converted internally to radians.
    If pixwin is True, the spectra is debeamed with the pixel window function.
    """
    if sky_map.ndim == 1:
        pol = False
    else:
        pol = True

    if binary_mask is not None:
        sky_map_masked = mu.mask_map(sky_map, binary_mask=binary_mask, pol=pol)
        f_sky = mu.get_sky_fraction(binary_mask)
    else:
        sky_map_masked = sky_map
        if hp.maptype == 0:
            f_sky = 1.0
        else:
            f_sky = np.aray([1.0, 1.0, 1.0])

    Bl = hp.gauss_beam(fwhm=np.radians(fwhm / 60.0), lmax=lmax, pol=pol)
    if pixwin:
        pixel_window = hp.pixwin(hp.get_nside(sky_map), pol)

    if pol:
        spectra = hp.anafast(sky_map_masked.filled(), lmax=lmax)[:4]
        spectra /= f_sky[1] * Bl.T**2
        if pixwin:
            spectra[0] /= pixwin[0]**2
            spectra[1:] /= pixwin[1]**2
    else:
        spectra = hp.anafast(sky_map_masked.filled(), lmax=lmax)
        spectra /= f_sky * Bl**2
        if pixwin:
            spectra /= pixel_window**2

    return spectra
Ejemplo n.º 34
0
def compute_ds_dcb(map,mask,ellmin,ellmax,fwhmrad):
    npix=np.size(np.where(mask))
    maxell=np.max(ellmax)
    ellbins=ellmin.size
    ellval=(ellmin+ellmax)/2
    print('    Calculating dS/dCb')
    pixwin=hp.pixwin(hp.npix2nside(len(map)))[0:maxell+1]
    ll=np.arange(int(maxell)+1)
    bl=np.exp(-0.5*ll**2*(fwhmrad/2.35)**2)
    
    nside=np.sqrt(map.size/12)
    iprings=np.arange(map.size)
    vecs=hp.pix2vec(int(nside),iprings[mask])
    cosangles=np.dot(np.transpose(vecs),vecs)
    
    ds_dcb=np.zeros((ellbins,npix,npix))
    for i in np.arange(npix):
        bla,aa=do_a_line(cosangles[i,:],i,ll,bl,pixwin,ellmin,ellmax,ellval)
        ds_dcb[:,i,i:]=bla[:,i:]
        ds_dcb[:,i:,i]=bla[:,i:]
    
    return(ds_dcb)
Ejemplo n.º 35
0
    def apply_ivf(self, det, tmap, pmap):
        assert(self.lmax == 1000)

        mask_t = qcinv.util.load_map(self.mask_t)
        mask_p = qcinv.util.load_map(self.mask_p)

        bl  = dmc.get_bl(self.sim_lib.year, det)[0:self.lmax+1]
        pxw = hp.pixwin( self.sim_lib.nside )[0:self.lmax+1]

        # qcinv filtering for temperature
        dcf = self.lib_dir + "/dense_cache_det_" + det + ".pk"
        #                  id         preconditioners                 lmax    nside     im      em            tr                      cache
        chain_descr = [ [  2, ["split(dense("+dcf+"), 32, diag_cl)"],  256,   128,       3,     0.0,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()],
                        [  1, ["split(stage(2), 256, diag_cl)"],       512,   256,       3,     0.0,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()],
                        [  0, ["split(stage(1), 512, diag_cl)"],      1000,   512,  np.inf,  1.0e-6,  qcinv.cd_solve.tr_cg,  qcinv.cd_solve.cache_mem()] ]

        # temperature noise covariance
        ninv_t = ( hp.read_map( dmc.get_fname_iqumap(self.sim_lib.year, det, self.sim_lib.forered), hdu=1, field=3 ) /
                   dmc.sigma0[(self.sim_lib.year, self.sim_lib.forered, 'T')][det]**2 / 1e6 * mask_t )

        # polarization noise covariance
        tfname =  dmc.get_fname_iqumap(self.sim_lib.year, det, False) #NOTE: Nobs counts taken from non-FG reduced maps.

        n_inv_qq = hp.read_map( tfname, hdu=2, field=1 ) / (dmc.sigma0[(self.sim_lib.year, self.sim_lib.forered, 'P')][det] * 1.e3)**2 * mask_p
        n_inv_qu = hp.read_map( tfname, hdu=2, field=2 ) / (dmc.sigma0[(self.sim_lib.year, self.sim_lib.forered, 'P')][det] * 1.e3)**2 * mask_p
        n_inv_uu = hp.read_map( tfname, hdu=2, field=3 ) / (dmc.sigma0[(self.sim_lib.year, self.sim_lib.forered, 'P')][det] * 1.e3)**2 * mask_p

        # construct filter
        if self.diag_n == True:
            n_inv_filt = qcinv.opfilt_tp.alm_filter_ninv( [ninv_t, 0.5*(n_inv_qq + n_inv_uu)], bl*pxw, marge_monopole=True, marge_dipole=True )
        else:
            n_inv_filt = qcinv.opfilt_tp.alm_filter_ninv( [ninv_t, n_inv_qq, n_inv_qu, n_inv_uu], bl*pxw, marge_monopole=True, marge_dipole=True )

        chain = qcinv.multigrid.multigrid_chain( qcinv.opfilt_tp, chain_descr, self.cl, n_inv_filt )

        alm = qcinv.opfilt_tp.teblm( [np.zeros( qcinv.util_alm.lmax2nlm(self.lmax), dtype=np.complex ) for i in xrange(0,3)] )
        chain.solve( alm, [tmap, pmap.real, pmap.imag] )

        return alm.tlm, alm.elm, alm.blm
Ejemplo n.º 36
0
def Clgg(gal_map, gal_mask, N_side, lmax, normalized=False):
    # CMASS map, number counts. Should convert to delta_n/n
    gal = hp.read_map(gal_map)
    if gal_mask != False:
        gal_mask = hp.read_map(gal_mask)
        gal_mask = hp.ud_grade(gal_mask, N_side)  # Bring to same resolution
    else:
        gal_mask = np.ones_like(gal)

    # The mask is product of PLANCK lensing and CMASS masks
    mask = gal_mask
    fsky = np.sum(mask) * 1. / len(mask)

    # Apply the mask. Same for all, for now
    masked_pl = mask
    masked_gal = gal * mask

    # Compute shot noise
    mean_gal = np.sum(masked_gal) / np.sum(mask)
    A_per_healpix = (4 * np.pi) / (12 * N_side**2)
    shot_noise = (mean_gal / A_per_healpix)**(-1.)

    # Normalized tells you if the map has already been normalized or is a raw map of counts
    if normalized == False:
        mean_gal = np.sum(masked_gal) / np.sum(mask)
        masked_gal_dn = masked_gal / mean_gal - 1.
        masked_gal_dn = mask * masked_gal_dn
    else:
        masked_gal_dn = masked_gal

    Clgg = hp.anafast(masked_gal_dn, lmax=lmax)
    ls = np.arange(len(Clgg))
    pixwinf = hp.pixwin(N_side)[0:len(Clgg)]

    Clgg = Clgg / (pixwinf**2)
    Clgg = Clgg / fsky

    return ls, Clgg, fsky, shot_noise
Ejemplo n.º 37
0
def load_chan_realization(chan_fmt, chani, reali, lmax,
                          doppler=True, beam=r2_channel_beams):
    '''
    Loads a single array of `D_\ells` from an FFP8 fits file, adjusting for the
    observation beam and (possibly) for doppler modulation. Returns the TT
    power spectrum for `\ell = 0` to `\ell = lmax`, inclusive.

    chan_fmt: Path to the .fits file.
    chani: Planck observation channel, 0 <= chani < 9. I.e. 0 means 30 GHz.
    reali: The realization number.
    doppler: Whether to remove doppler modulation from the realization.

    returns: An array of `D_\ell = \ell (\ell + 1) / (2 \pi) C_\ell`.
             A `numpy.array` of `dtype == np.double` and size `lmax + 1`.
    '''
    m = hp.read_map(chan_fmt.format(freq=planck_freqs[chani], real=reali))
    if chani >= 7:
        m /= cfact_545_857[chani - 7]

    if doppler:
        m = doppler_adjust(m, chani)

    cls = hp.anafast(1e6*m, lmax=lmax)
    ells = np.arange(lmax + 1)
    ll1 = ells * (ells + 1) / (2 * np.pi)

    nside = hp.npix2nside(m.size)
    beam = beam[chani, :lmax + 1] * hp.pixwin(nside)[:lmax + 1]

    beam_msk = beam != 0

    # Avoid divide-by-zero warnings
    adj_dls = np.zeros_like(cls)
    adj_dls[beam_msk] = (ll1 * cls)[beam_msk] / beam[beam_msk]**2

    return adj_dls
Ejemplo n.º 38
0
), 'Set env. variable PLENS to a writeable folder'
TEMP = os.path.join(os.environ['PLENS'], 'temp', 'anisofilt_example')
cls_path = os.path.join(os.path.dirname(os.path.abspath(plancklens.__file__)),
                        'data', 'cls')

#--- definition of simulation and inverse-variance filtered simulation libraries:
lmax_ivf = 2048
lmin_ivf = 100  # We will use in the QE only CMB modes between lmin_ivf and lmax_ivf
lmax_qlm = 4096  # We will calculate lensing estimates until multipole lmax_qlm.
nside = 2048  # Healpix resolution of the data and sims.
nlev_t = 35.  # Filtering noise level in temperature (here also used for the noise simulations generation).
nlev_p = 55.  # Filtering noise level in polarization (here also used for the noise simulations generation).
nsims = 300  # Total number of simulations to consider.

transf = hp.gauss_beam(5. / 60. / 180. * np.pi,
                       lmax=lmax_ivf) * hp.pixwin(nside)[:lmax_ivf + 1]
#: CMB transfer function. Here a 5' Gaussian beam and healpix pixel window function.

cl_unl = utils.camb_clfile(
    os.path.join(cls_path, 'FFP10_wdipole_lenspotentialCls.dat'))
cl_len = utils.camb_clfile(
    os.path.join(cls_path, 'FFP10_wdipole_lensedCls.dat'))
#: Fiducial unlensed and lensed power spectra used for the analysis.

cl_weight = utils.camb_clfile(
    os.path.join(cls_path, 'FFP10_wdipole_lensedCls.dat'))
cl_weight['bb'] *= 0.
#: CMB spectra entering the QE weights (the spectra multplying the inverse-variance filtered maps in the QE legs)

libdir_pixphas = os.path.join(TEMP, 'pix_phas_nside%s' % nside)
pix_phas = phas.pix_lib_phas(libdir_pixphas, 3, (hp.nside2npix(nside), ))
Ejemplo n.º 39
0
    #Smoothing W-beam for 're-convolving'
    '''smoothbeam = cp.deepcopy(combbeam[4])
    smoothbegin = 875
    smoothend = 1024
    smoothbeam[smoothbegin:smoothend+1] = smoothfunc(np.arange(smoothbegin,smoothend+1),smoothbeam[smoothbegin])'''
    #For Planck, effective beam is 5' FWHM gaussian
    smoothbeam = hp.gauss_beam(mh.radians(5. / 60.), lmax=ellmax - 1)
    '''smoothbegin = 3400
    smoothend = ellmax-1
    smoothbeam[smoothbegin:smoothend+1] = smoothfunc(np.arange(smoothbegin,smoothend+1),smoothbeam[smoothbegin])
    smoothbeam_orig = hp.gauss_beam(mh.radians(5./60.),lmax=ellmax-1)'''

    #Take reciprocal of beam transfer functions
    #pixrecip = np.reciprocal(hp.pixwin(hp.get_nside(maps))[:ellmax+1]) #TESTING pixwin
    pixrecip1024 = np.reciprocal(
        hp.pixwin(1024)[:ellmax])  #30 & 44 GHz at Nside=1024
    pixrecip2048 = np.reciprocal(
        hp.pixwin(2048)[:ellmax])  #70 & HFI @ Nside=2048 #Not 70 for MC
    recipcombbeam = np.reciprocal(rawbeam)  #combbeam)

    #Thresholding of deconvolved beams to 1/b_l <= 1000
    recipcombbeam[recipcombbeam > 1000] = 1000

    deconbeam = [None] * len(recipcombbeam)
    for i in xrange(2):  #len(recipcombbeam)):
        deconbeam[i] = recipcombbeam[
            i] * smoothbeam * pixrecip1024  #Deconvolving to tapered 5' gaussian beam
    for i in xrange(2, len(recipcombbeam)):
        deconbeam[i] = recipcombbeam[
            i] * smoothbeam * pixrecip2048  #Deconvolving to tapered 5' gaussian beam
    deconbeam = np.array(deconbeam)
Ejemplo n.º 40
0
clf()
plot(theell, sigcosvardee / samplevar_th_ee, 'r', label = 'EE: MC / Knox')
plot(theell, sigcosvardee / deltacl_ee_like, 'r--', label = 'EE: MC / Likelihood')
plot(theell, sigcosvardbb / samplevar_th_bb, 'b', label = 'BB: MC / Knox')
plot(theell, sigcosvardbb / deltacl_bb_like, 'b--', label = 'BB: MC / Likelihood')
ylim(0,2)
legend(numpoints=1)




##### Noise variance
signoisedee = sigdee-sigdee[0,:]
signoisedbb = sigdbb-sigdbb[0,:]

pixwin=hp.pixwin(nside)[0:max(ll)+1]
omega = 4* pi * fsky

fact = 2 * np.interp(theell, ell, np.sqrt(2./((2*ell+1)*fsky))) / np.sqrt(ellmax-ellmin) * theell * (theell +1) / (2*pi) / np.interp(theell, ll,bl**2*pixwin**2) * omega

clf()
subplot(1,2,1)
for i in xrange(4, len(allvalnoise)):
    plot(theell, signoisedee[i,:], label='$\sigma$ = {}'.format(allvalnoise[i]), color=cm.jet(allvalnoise[i]/max(allvalnoise)))
    plot(theell, (fact * allvalnoise[i]**2)/100, '--', color=cm.jet(allvalnoise[i]/max(allvalnoise)))
legend(fontsize=8, loc='upper left')
yscale('log')
subplot(1,2,2)
for i in xrange(4, len(allvalnoise)):
    plot(theell, signoisedbb[i,:], label='$\sigma$ = {}'.format(allvalnoise[i]), color=cm.jet(allvalnoise[i]/max(allvalnoise)))
    plot(theell, (fact * allvalnoise[i]**2)/1000, '--', color=cm.jet(allvalnoise[i]/max(allvalnoise)))
def test(useCLASS=1,
         useLensing=1,
         classCamb=1,
         nSims=1000,
         lmax=100,
         lmin=2,
         newSMICA=False,
         newDeg=False,
         suppressC2=False,
         suppFactor=0.23,
         filterC2=False,
         filtFacLow=0.1,
         filtFacHigh=0.2,
         R1=False):
    """
    code for testing the other functions in this module
    Inputs:
      useCLASS: set to 1 to use CLASS, 0 to use CAMB
        CLASS Cl has early/late split at z=50
        CAMB Cl has ISWin/out split: ISWin: 0.4<z<0.75, ISWout: the rest
        Note: CAMB results include primary in ISWin and ISWout (not as intended)
        default: 1
      useLensing: set to 1 to use lensed Cl, 0 for non-lensed
        default: 1
      classCamb: if 1: use the CAMB format of CLASS output, if 0: use CLASS format
        Note: parameter not used if useCLASS = 0
        default: 1
      nSims: the number of simulations to do for ensemble
        default: 1000
      lmax: the highest l to include in Legendre transforms
        default: 100
      lmin: the lowest l to include in S_{1/2} = CIC calculations
        default: 2
      newSMICA: set to True to recalculate SMICA results
        default: False
      newDeg: set to True to recalculate map and mask degredations
        (only if newSMICA is also True)
        default: False
      suppressC2: set to True to suppress theoretical C_2 (quadrupole) by 
        suppFactor before creating a_lm.s
        Default: False
      suppFactor: multiplies C_2 if suppressC2 is True
        Default: 0.23 # from Tegmark et. al. 2003, figure 13 (WMAP)
      filterC2 : set to true to filter simulated CMBs after spice calculates
        cut sky C_l.  Sims will pass filter if C_2 * filtFacLow < C_2^sim <
        C_2 * filtFacHigh.
        Default: False
      filtFacLow,filtFacHigh: defines C_2 range for passing simulated CMBs
        Default: 0.1,0.2
      R1: set to True to use SMICA and Mask R1.  Otherwise, R2 used.
        Only affects calculation of newly degraded map.
        Default: False
  """

    # load data
    ell, fullCl, primCl, lateCl, crossCl = gcp.loadCls(useCLASS=useCLASS,
                                                       useLensing=useLensing,
                                                       classCamb=classCamb)

    # fill beginning with zeros
    startEll = int(ell[0])
    ell = np.append(np.arange(startEll), ell)
    fullCl = np.append(np.zeros(startEll), fullCl)
    primCl = np.append(np.zeros(startEll), primCl)
    lateCl = np.append(np.zeros(startEll), lateCl)
    crossCl = np.append(np.zeros(startEll), crossCl)

    # suppress C_2 to see what happens in enesmble
    if suppressC2:
        fullCl[2] *= suppFactor
        primCl[2] *= suppFactor
        lateCl[2] *= suppFactor
        crossCl[2] *= suppFactor

    conv = ell * (ell + 1) / (2 * np.pi)
    #print ell,conv #ell[0]=2.0
    """
  # verify statistical properties of alm realizations
  nSims = 1000
  lmax = 100
  Clprim_sum = np.zeros(lmax+1)
  Cllate_sum = np.zeros(lmax+1)
  Clcros_sum = np.zeros(lmax+1) # prim x late
  for nSim in range(nSims):
    print 'starting sim ',nSim+1, ' of ',nSims
    #alm_prim,alm_late = getAlms(A_lij,lmax=lmax) #AKW method defunct
    # see if synalm can do it
    alm_prim,alm_late = hp.synalm((primCl,lateCl,crossCl),lmax=lmax,new=True)
    Clprim_sum = Clprim_sum + hp.alm2cl(alm_prim)
    Cllate_sum = Cllate_sum + hp.alm2cl(alm_late)
    Clcros_sum = Clcros_sum + hp.alm2cl(alm_prim,alm_late)
  Cl_prim_avg = Clprim_sum/nSims
  Cl_late_avg = Cllate_sum/nSims
  Cl_cros_avg = Clcros_sum/nSims

  doPlot = True
  if doPlot:
    plt.plot(ell[:lmax+1],Cl_prim_avg*conv[:lmax+1])
    plt.plot(ell[:lmax+1],primCl[:lmax+1]*conv[:lmax+1])
    plt.title('primary')
    plt.ylabel('D_l')
    plt.show()

    plt.plot(ell[:lmax+1],Cl_late_avg*conv[:lmax+1])
    plt.plot(ell[:lmax+1],lateCl[:lmax+1]*conv[:lmax+1])
    plt.title('late')
    plt.ylabel('D_l')
    plt.show()

    plt.plot(ell[:lmax+1],Cl_cros_avg*conv[:lmax+1])
    plt.plot(ell[:lmax+1],crossCl[:lmax+1]*conv[:lmax+1])
    plt.title('cross')
    plt.ylabel('D_l')
    plt.show()
  """

    # get covariances from SMICA map and mask
    theta_i = 0.0  #degrees
    theta_f = 180.0  #degrees
    nSteps = 1800
    #lmax = 100
    """ # don't want anafast after all

  # get unmasked and masked SMICA covariances
  #   note: getSMICA uses linspace in theta for thetaArray
  #newSMICA = False#True
  thetaArray2, C_SMICA, C_SMICAmasked, S_SMICAnomask, S_SMICAmasked = \
    getSMICA(theta_i=theta_i,theta_f=theta_f,nSteps=nSteps,lmax=lmax,lmin=lmin,
             newSMICA=newSMICA,newDeg=newDeg,useSPICE=False,R1=R1)
  print ''
  print 'S_{1/2}(anafast): SMICA, no mask: ',S_SMICAnomask,', masked: ',S_SMICAmasked
  print ''
  """

    # get C_l from SPICE to compare to above method
    #   note: getSMICA uses linspace in theta for thetaArray
    #newSMICA = False#True
    thetaArray2sp, C_SMICAsp, C_SMICAmaskedsp, S_SMICAnomasksp, S_SMICAmaskedsp = \
      getSMICA(theta_i=theta_i,theta_f=theta_f,nSteps=nSteps,lmax=lmax,lmin=lmin,
               newSMICA=newSMICA,newDeg=newDeg,useSPICE=True,R1=R1)
    print ''
    print 'S_{1/2}(spice): SMICA, no mask: ', S_SMICAnomasksp, ', masked: ', S_SMICAmaskedsp
    print ''

    # Find S_{1/2} in real space to compare methods
    nTerms = 10000
    #SSnm2   = SOneHalf(thetaArray2,  C_SMICA,         nTerms=nTerms)
    #SSmd2   = SOneHalf(thetaArray2,  C_SMICAmasked,   nTerms=nTerms)
    SSnm2sp = SOneHalf(thetaArray2sp, C_SMICAsp, nTerms=nTerms)
    SSmd2sp = SOneHalf(thetaArray2sp, C_SMICAmaskedsp, nTerms=nTerms)

    # create ensemble of realizations and gather statistics
    covEnsembleFull = np.zeros([nSims, nSteps + 1])  # for maskless
    covEnsembleCut = np.zeros([nSims, nSteps + 1])  # for masked
    sEnsembleFull = np.zeros(nSims)
    sEnsembleCut = np.zeros(nSims)
    covTheta = np.array([])
    #nSims = 1000

    # apply beam and pixel window functions to power spectra
    #   note: to ignore the non-constant pixel shape, W(l) must be > B(l)
    #     however, this is not true for NSIDE=128 and gauss_beam(5')
    #   Here I ignore this anyway and proceed
    myNSIDE = 128  # must be same NSIDE as in getSMICA function
    Wpix = hp.pixwin(myNSIDE)
    Bsmica = hp.gauss_beam(5. / 60 * np.pi / 180)  # 5 arcmin
    WlMax = Wpix.size
    if WlMax < lmax:
        print 'die screaming!!!'
        return 0
    primCl = primCl[:WlMax] * (Wpix * Bsmica)**2
    lateCl = lateCl[:WlMax] * (Wpix * Bsmica)**2
    crossCl = crossCl[:WlMax] * (Wpix * Bsmica)**2
    # note: i tried sims without this scaling, and results seemed the same at a glance

    # collect simulated Cl for comparison to model
    Clsim_full_sum = np.zeros(lmax + 1)

    # get Jmn matrix for harmonic space S_{1/2} calc.
    myJmn = getJmn(lmax=lmax)

    # set up ramdisk for SpICE
    # super lame that spice needs to read/write from disk, but here goes...
    RAMdisk = '/Volumes/ramdisk/'
    ClTempFile = RAMdisk + 'tempCl.fits'
    mapTempFile = RAMdisk + 'tempMap.fits'
    mapDegFile = RAMdisk + 'smicaMapDeg.fits'  # this should have been created by sims.getSMICA
    maskDegFile = RAMdisk + 'maskMapDeg.fits'  # this should have been created by sims.getSMICA

    # create RAM Disk for SpICE and copy these files there using bash
    RAMsize = 4  #Mb
    ramDiskOutput = subprocess.check_output('./ramdisk.sh create ' +
                                            str(RAMsize),
                                            shell=True)
    print ramDiskOutput
    diskID = ramDiskOutput[
        31:41]  # this might not grab the right part; works for '/dev/disk1'
    subprocess.call('cp smicaMapDeg.fits ' + RAMdisk, shell=True)
    subprocess.call('cp maskMapDeg.fits ' + RAMdisk, shell=True)

    doTime = True  # to time the run and print output
    startTime = time.time()
    #for nSim in range(nSims):
    nSim = 0
    while nSim < nSims:
        print 'starting sim ', nSim + 1, ' of ', nSims
        alm_prim, alm_late = hp.synalm((primCl, lateCl, crossCl),
                                       lmax=lmax,
                                       new=True)

        # calculate C(theta) of simulation
        Clsim_prim = hp.alm2cl(alm_prim)
        Clsim_late = hp.alm2cl(alm_late)
        Clsim_cros = hp.alm2cl(alm_prim, alm_late)
        Clsim_full = Clsim_prim + 2 * Clsim_cros + Clsim_late
        # use Cl_sim_full to omit prim/late distinction for now

        # start with a mask
        #   -> for optional C2 filtering based on cut sky map
        #   alm2map should create map with default RING ordering
        #   pixel window and beam already accounted for in true Cls
        #mapSim = hp.alm2map(alm_prim+alm_late,myNSIDE,lmax=lmax,pixwin=True,sigma=5./60*np.pi/180)
        mapSim = hp.alm2map(alm_prim + alm_late, myNSIDE, lmax=lmax)

        hp.write_map(mapTempFile, mapSim)
        ispice(mapTempFile,
               ClTempFile,
               maskfile1=maskDegFile,
               subav="YES",
               subdipole="YES")
        Cl_masked = hp.read_cl(ClTempFile)
        ell2 = np.arange(Cl_masked.shape[0])

        # Check for low power of cut sky C_2
        if (filterC2 == True and fullCl[2] * filtFacHigh > Cl_masked[2] and
                Cl_masked[2] > fullCl[2] * filtFacLow) or filterC2 == False:

            #   note: getCovar uses linspace in x for thetaArray
            thetaArray, cArray2 = getCovar(ell2[:lmax + 1],
                                           Cl_masked[:lmax + 1],
                                           theta_i=theta_i,
                                           theta_f=theta_f,
                                           nSteps=nSteps,
                                           lmin=lmin)
            covEnsembleCut[nSim] = cArray2

            # S_{1/2}
            sEnsembleCut[nSim] = np.dot(
                Cl_masked[lmin:lmax + 1],
                np.dot(myJmn[lmin:, lmin:], Cl_masked[lmin:lmax + 1]))

            doPlot = False  #True
            if doPlot:
                plt.plot(thetaArray, cArray)
                plt.xlabel('theta (degrees)')
                plt.ylabel('C(theta)')
                plt.title('covariance of CMB simulation ' + str(nSim + 1))
                plt.show()

            # now without the mask
            # uses the same sims that passed the C2 filter
            Clsim_full_sum += Clsim_full

            #   note: getCovar uses linspace in x for thetaArray
            thetaArray, cArray = getCovar(ell[:lmax + 1],
                                          Clsim_full[:lmax + 1],
                                          theta_i=theta_i,
                                          theta_f=theta_f,
                                          nSteps=nSteps,
                                          lmin=lmin)
            covEnsembleFull[nSim] = cArray
            covTheta = thetaArray

            # S_{1/2}
            sEnsembleFull[nSim] = np.dot(
                Clsim_full[lmin:],
                np.dot(myJmn[lmin:, lmin:], Clsim_full[lmin:]))

            nSim += 1

    if doTime:
        print 'time elapsed: ', int(
            (time.time() - startTime) / 60.), ' minutes'

    # free the RAM used by SpICE's RAM disk
    ramDiskOutput = subprocess.check_output('./ramdisk.sh delete ' + diskID,
                                            shell=True)
    print ramDiskOutput

    avgEnsembleFull = np.average(covEnsembleFull, axis=0)
    stdEnsembleFull = np.std(covEnsembleFull, axis=0)
    # do I need a better way to describe confidence interval?
    avgEnsembleCut = np.average(covEnsembleCut, axis=0)
    stdEnsembleCut = np.std(covEnsembleCut, axis=0)

    Clsim_full_avg = Clsim_full_sum / nSims

    # save results
    saveFile1 = "simStatResultC.npy"
    np.save(
        saveFile1,
        np.vstack((thetaArray, avgEnsembleFull, stdEnsembleFull,
                   avgEnsembleCut, stdEnsembleCut)))
    saveFile2 = "simStatC_SMICA.npy"
    np.save(saveFile2, np.vstack((thetaArray2sp, C_SMICAsp, C_SMICAmaskedsp)))

    saveFile3 = "simStatResultS.npy"
    np.save(
        saveFile3,
        np.vstack((np.hstack((np.array(S_SMICAnomasksp), sEnsembleFull)),
                   np.hstack((np.array(S_SMICAmaskedsp), sEnsembleCut)))))

    doPlot = True
    if doPlot:
        print 'plotting C_l... '
        #print ell.size,conv.size,primCl.size,crossCl.size,lateCl.size
        plt.plot(ell[:lmax + 1],
                 conv[:lmax + 1] * (primCl + 2 * crossCl + lateCl)[:lmax + 1],
                 label='model D_l')
        plt.plot(ell[:lmax + 1],
                 conv[:lmax + 1] * Clsim_full_avg,
                 label='ensemble average D_l')
        plt.legend()
        plt.show()

        makePlots(saveFile1=saveFile1,
                  saveFile2=saveFile2,
                  saveFile3=saveFile3)

    # S_{1/2} output
    print ''
    print 'using CIC method: '
    #print 'S_{1/2}(anafast): SMICA, no mask: ',S_SMICAnomask,', masked: ',S_SMICAmasked
    print 'S_{1/2}(spice): SMICA, no mask: ', S_SMICAnomasksp, ', masked: ', S_SMICAmaskedsp
    print ''
    print 'using CCdx method: '
    #print 'S_{1/2}(anafast): SMICA, no mask: ',SSnm2,', masked: ',SSmd2
    print 'S_{1/2}(spice): SMICA, no mask: ', SSnm2sp, ', masked: ', SSmd2sp
    print ''
Ejemplo n.º 42
0
#### Get MC results
mclsout = np.zeros(nbins)
sclsout = np.zeros(nbins)
for j in np.arange(nbins):
	mclsout[j] = np.mean(allclsout[:,j])
	sclsout[j] = np.std(allclsout[:,j])/sqrt(nbmc)

mcls = np.zeros(lmax+1)
scls = np.zeros(lmax+1)
for j in np.arange(lmax+1):
	mcls[j] = np.mean(allcls[:,j])
	scls[j] = np.std(allcls[:,j])/sqrt(nbmc)


ell = np.arange(lmax+1)
pw = hp.pixwin(nside)[0:lmax+1]
pwb = np.interp(newl,ell,pw)
fact = ell * (ell + 1) / (2 * np.pi) * len(maskmap) / maskok.sum()
factth = lll * (lll + 1) / (2 * np.pi)

clf()
subplot(2,1,1)
title('TT')
xlim(0,lmax)
errorbar(newl,mclsout/pwb**2,yerr=sclsout,fmt='bo',label='Corrected')
plot(ell,fact*mcls/pw**2,'g',label='Anafast rescaled')
plot(spectra[0],spectra[1]*factth,'r',label='Input')
legend(loc='lower right',frameon=False,fontsize=10)

subplot(2,1,2)
title('Residuals')
Ejemplo n.º 43
0
def test(useCLASS=1,
         useLensing=1,
         classCamb=1,
         nSims=1000,
         lmax=100,
         lmin=2,
         newSMICA=False,
         newDeg=False,
         suppressC2=False,
         suppFactor=0.23):
    """
    code for testing the other functions in this module
    Inputs:
      useCLASS: set to 1 to use CLASS, 0 to use CAMB
        CLASS Cl has early/late split at z=50
        CAMB Cl has ISWin/out split: ISWin: 0.4<z<0.75, ISWout: the rest
        Note: CAMB results include primary in ISWin and ISWout (not as intended)
        default: 1
      useLensing: set to 1 to use lensed Cl, 0 for non-lensed
        default: 1
      classCamb: if 1: use the CAMB format of CLASS output, if 0: use CLASS format
        Note: parameter not used if useCLASS = 0
        default: 1
      nSims: the number of simulations to do for ensemble
        default: 1000
      lmax: the highest l to include in Legendre transforms
        default: 100
      lmin: the lowest l to include in S_{1/2} = CIC calculations
        default: 2
      newSMICA: set to True to recalculate SMICA results
        default: False
      newDeg: set to True to recalculate map and mask degredations
        (only if newSMICA is also True)
        default: False
      suppressC2: set to True to suppress theoretical C_2 by suppFactor
        before creating a_lm.s
        Default: False
      suppFactor: multiplies C_2 if suppressC2 is True
        Default: 0.23 # from Tegmark et. al. 2003, figure 13 (WMAP)
  """

    ##############################################################################
    # load theoretical power spectra

    # load data
    ell, fullCl, primCl, lateCl, crossCl = gcp.loadCls(useCLASS=useCLASS,
                                                       useLensing=useLensing,
                                                       classCamb=classCamb)

    # fill beginning with zeros
    startEll = int(ell[0])
    ell = np.append(np.arange(startEll), ell)
    fullCl = np.append(np.zeros(startEll), fullCl)
    primCl = np.append(np.zeros(startEll), primCl)
    lateCl = np.append(np.zeros(startEll), lateCl)
    crossCl = np.append(np.zeros(startEll), crossCl)

    # suppress C_2 to see what happens in enesmble
    #suppressC2 = False
    #suppFactor = 0.23 # from Tegmark et. al. 2003, figure 13 (WMAP)
    if suppressC2:
        fullCl[2] *= suppFactor
        primCl[2] *= suppFactor
        lateCl[2] *= suppFactor
        crossCl[2] *= suppFactor

    conv = ell * (ell + 1) / (2 * np.pi)
    #print ell,conv #ell[0]=2.0

    # apply beam and pixel window functions to power spectra
    #   note: to ignore the non-constant pixel shape, W(l) must be > B(l)
    #     however, this is not true for NSIDE=128 and gauss_beam(5')
    #   Here I ignore this anyway and proceed
    myNSIDE = 128  # must be same NSIDE as in sims.getSMICA function
    Wpix = hp.pixwin(myNSIDE)
    Bsmica = hp.gauss_beam(5. / 60 * np.pi / 180)  # 5 arcmin
    WlMax = Wpix.size
    if WlMax < lmax:
        print 'die screaming!!!'
        return 0
    fullCl = fullCl[:WlMax] * (Wpix * Bsmica)**2
    primCl = primCl[:WlMax] * (Wpix * Bsmica)**2
    lateCl = lateCl[:WlMax] * (Wpix * Bsmica)**2
    crossCl = crossCl[:WlMax] * (Wpix * Bsmica)**2
    # note: i tried sims without this scaling, and results seemed the same at a glance

    ##############################################################################
    # load SMICA data, converted to C(theta), via SpICE

    if newSMICA:
        theta_i = 0.0  #degrees
        theta_f = 180.0  #degrees
        nSteps = 1800
        thetaArray2sp, C_SMICAsp, C_SMICAmaskedsp, S_SMICAnomasksp, S_SMICAmaskedsp = \
          sims.getSMICA(theta_i=theta_i,theta_f=theta_f,nSteps=nSteps,lmax=lmax,lmin=lmin,
                   newSMICA=newSMICA,newDeg=newDeg,useSPICE=True)

    # filenames for SpICE to use
    # super lame that spice needs to read/write from disk, but here goes...
    RAMdisk = '/Volumes/ramdisk/'
    ClTempFile = RAMdisk + 'tempCl.fits'
    mapTempFile = RAMdisk + 'tempMap.fits'
    mapDegFile = RAMdisk + 'smicaMapDeg.fits'  # this should have been created by sims.getSMICA
    maskDegFile = RAMdisk + 'maskMapDeg.fits'  # this should have been created by sims.getSMICA

    # create RAM Disk for SpICE and copy these files there using bash
    RAMsize = 4  #Mb
    ramDiskOutput = subprocess.check_output('./ramdisk.sh create ' +
                                            str(RAMsize),
                                            shell=True)
    print ramDiskOutput
    diskID = ramDiskOutput[
        31:41]  # this might not grab the right part; works for '/dev/disk1'
    subprocess.call('cp smicaMapDeg.fits ' + RAMdisk, shell=True)
    subprocess.call('cp maskMapDeg.fits ' + RAMdisk, shell=True)

    ispice(mapDegFile,
           ClTempFile,
           maskfile1=maskDegFile,
           subav="YES",
           subdipole="YES")
    ClsmicaCut = hp.read_cl(ClTempFile)

    # find S_{1/2} for SMICA.  Should actually optimize but see what happens here first.
    #myJmn = legprodint.getJmn(endX=0.5,lmax=lmax,doSave=False)
    #Ssmica = np.dot(ClsmicaCut[lmin:lmax+1],np.dot(myJmn[lmin:,lmin:],
    #                ClsmicaCut[lmin:lmax+1]))*1e24 #K^4 to microK^4

    ##############################################################################
    # create ensemble of realizations and gather statistics

    spiceMax = myNSIDE * 3  # should be lmax+1 for SpICE
    ClEnsembleCut = np.zeros([nSims, spiceMax])
    simEll = np.arange(spiceMax)

    doTime = True  # to time the run and print output
    startTime = time.time()
    for nSim in range(nSims):
        print 'starting masked Cl sim ', nSim + 1, ' of ', nSims
        alm_prim, alm_late = hp.synalm((primCl, lateCl, crossCl),
                                       lmax=lmax,
                                       new=True)
        mapSim = hp.alm2map(alm_prim + alm_late, myNSIDE, lmax=lmax)
        hp.write_map(mapTempFile, mapSim)

        ispice(mapTempFile,
               ClTempFile,
               maskfile1=maskDegFile,
               subav="YES",
               subdipole="YES")
        ClEnsembleCut[nSim] = hp.read_cl(ClTempFile)

        doPlot = False  #True
        if doPlot:
            gcp.showCl(simEll[:lmax + 1],
                       ClEnsembleCut[nSim, :lmax + 1],
                       title='power spectrum of simulation ' + str(nSim + 1))

    timeInterval1 = time.time() - startTime
    if doTime: print 'time elapsed: ', int(timeInterval1 / 60.), ' minutes'

    # free the RAM used by SpICE's RAM disk
    ramDiskOutput = subprocess.check_output('./ramdisk.sh delete ' + diskID,
                                            shell=True)
    print ramDiskOutput

    # put SMICA in as 0th member of the ensemble; 1e12 to convert K^2 to microK^2
    ClEnsembleCut = np.vstack((ClsmicaCut * 1e12, ClEnsembleCut))
    nSims += 1

    ##############################################################################
    # create S(x) for each C_l, using interpolation

    nXvals = 181
    thetaVals = np.linspace(0, 180, nXvals)  # one degree intervals
    xVals = np.cos(thetaVals * np.pi / 180)
    Jmnx = np.empty([nXvals, lmax + 1, lmax + 1])
    for index, xVal in enumerate(xVals):
        Jmnx[index] = legprodint.getJmn(endX=xVal, lmax=lmax, doSave=False)
    SxToInterpolate = np.empty(nXvals)

    # create list of functions
    dummy = lambda x: x**2
    SofXList = [dummy for i in range(nSims)]

    for nSim in range(nSims):
        print 'starting S(x) sim ', nSim + 1, ' of ', nSims
        for index, xVal in enumerate(xVals):
            SxToInterpolate[index] = np.dot(
                ClEnsembleCut[nSim, lmin:lmax + 1],
                np.dot(Jmnx[index, lmin:, lmin:],
                       ClEnsembleCut[nSim, lmin:lmax + 1]))
        SofX = interp1d(xVals, SxToInterpolate)
        #SofXList = SofXList.append(SofX)
        # Apparently appending a function to an empty list is not allowed. Instead:
        SofXList[nSim] = SofX

        #print SofXList#[nSim]
        doPlot = False  #True
        if doPlot:
            nplotx = (nXvals - 1) * 10 + 1
            plotTheta = np.linspace(0, 180, nplotx)
            plotx = np.cos(plotTheta * np.pi / 180)
            plotS = SofXList[nSim](plotx)
            plt.plot(plotx, plotS)
            plt.title('S(x) for simulation ' + str(nSim + 1))
            plt.show()

    doPlot = True
    if doPlot:
        for nSim in range(nSims):
            nplotx = (nXvals - 1) * 10 + 1
            plotTheta = np.linspace(0, 180, nplotx)
            plotx = np.cos(plotTheta * np.pi / 180)
            plotS = SofXList[nSim](plotx)
            plt.plot(plotx, plotS, label='sim ' + str(nSim + 1))
        #plt.legend()
        plt.title('S(x) for ' + str(nSims) + ' simulations')
        plt.xlabel('x')
        plt.ylabel('S_x')
        plt.show()

    ##############################################################################
    # create Pval(x) for each S(x), using ensemble
    # Pval: probability of result equal to or more extreme

    # create list of functions
    PvalOfXList = [dummy for i in range(nSims)]

    for nSim in range(nSims):
        print 'starting Pval(x) sim ', nSim + 1, ' of ', nSims

        def PvalOfX(x):
            nUnder = 0  # will also include nEqual
            nOver = 0
            threshold = SofXList[nSim](x)
            for nSim2 in range(nSims):
                Sx = SofXList[nSim2](x)
                if Sx > threshold:
                    nOver += 1
                    #print "Over! mySx: ",Sx,", threshold: ",threshold
                else:
                    nUnder += 1
                    #print "Under! mySx: ",Sx,", threshold: ",threshold
            #print "nUnder: ",nUnder,", nOver: ",nOver
            return nUnder / float(nUnder + nOver)

        PvalOfXList[nSim] = PvalOfX

    ##############################################################################
    # find global minimum for each Pval(x)
    # simply use same xVals as above, at one degree intervals
    # if there are equal p-values along the range, the one with the highest xVal
    #   will be reported

    PvalMinima = np.empty(nSims)
    xValMinima = np.empty(nSims)

    doTime = True  # to time the run and print output
    startTime = time.time()
    for nSim in range(nSims):
        print 'starting minimum Pval(x) search for sim ', nSim + 1, ' of ', nSims
        PvalOfX = PvalOfXList[nSim]
        #print 'function: ',PvalOfX
        PvalMinima[nSim] = PvalOfX(1.0)
        xValMinima[nSim] = 1.0

        Pvals = np.empty(nXvals)
        for index, xVal in enumerate(
                xVals):  # will start from 1 and go down to -1
            myPval = PvalOfX(xVal)
            Pvals[index] = myPval
            #print "nSim: ",nSim,", n: ",index,", myPval: ",myPval,", PvalMinima[nSim]: ",PvalMinima[nSim]
            if myPval < PvalMinima[
                    nSim] and xVal > -0.999:  #avoid the instabililility
                PvalMinima[nSim] = myPval
                xValMinima[nSim] = xVal
                #print 'nSim: ',nSim+1,', new x for minimum Pval: ',xVal
        #raw_input("Finished sim "+str(nSim+1)+" of "+str(nSims)+".  Press enter to continue")

        doPlot = True  #False#True
        if doPlot:  # and np.random.uniform() < 0.1: #randomly choose about 1/10 of them
            plt.plot(xVals, Pvals)
            plt.vlines(xValMinima[nSim], 0, 1)
            plt.xlabel('x = cos(theta), min at ' + str(xValMinima[nSim]))
            plt.ylabel('P-value')
            plt.title('P-values for simulation ' + str(nSim + 1) + ' of ' +
                      str(nSims) + ', p_min = ' + str(PvalMinima[nSim]))
            plt.xlim(-1.05, 1.05)
            plt.ylim(-0.05, 1.05)
            plt.show()

    timeInterval2 = time.time() - startTime
    if doTime: print 'time elapsed: ', int(timeInterval2 / 60.), ' minutes'
    """
  # A MYSTERY!  Something about the following code causes Pvals to always take 
  #   the values of PvalOfXList[nSims](xVals)  WTF?  Omit for now. 
  #   Testing seems to indicate that PvalOfXList functions still have different
  #   locations in memory, but they all seem to be evaluating the same.
  #   However, when the previous block of code is copied to come again after
  #   this one, it behaves properly again.
  # see how well it did
  doPlot = False#True
  if doPlot:
    nPlots = 10
    for nPlot in range(nPlots):
      print 'plot ',nPlot+1,' of ',nPlots
      toPlot = nPlot#np.random.randint(0,high=nSims)
      #for nSim in range(nSims):
      Pvals = np.empty(nXvals)
      PvalOfX = PvalOfXList[nPlot]
      print 'function: ',PvalOfX
      for index, xVal in enumerate(xVals):
        Pvals[index] = PvalOfX(xVal)
        #print index,Pvals[index]
      #print Pvals
      plt.plot(xVals,Pvals)
      plt.vlines(xValMinima[toPlot],0,1)
      plt.xlabel('x = cos(theta), min at '+str(xValMinima[toPlot]))
      plt.ylabel('P-value')
      plt.title('P-values for simulation '+str(toPlot+1)+' of '+str(nSims))
      plt.show()
  """

    ##############################################################################
    # create distribution of S(xValMinima)

    SxEnsembleMin = np.empty(nSims)
    for nSim in range(nSims):
        SxEnsembleMin[nSim] = SofXList[nSim](xValMinima[nSim])

    # extract SMICA result
    Ssmica = SxEnsembleMin[0]

    ##############################################################################
    # plot/print results

    print 'plotting S_x distribution... '
    myBins = np.logspace(1, 7, 100)
    plt.axvline(x=Ssmica, color='g', linewidth=3, label='SMICA masked')
    plt.hist(SxEnsembleMin[1:], bins=myBins, histtype='step', label='cut sky')
    # [1:] to omit SMICA value

    plt.gca().set_xscale("log")
    plt.legend()
    plt.xlabel('S_x (microK^4)')
    plt.ylabel('Counts')
    plt.title('S_x of ' + str(nSims - 1) +
              ' simulated CMBs')  #-1 due to SMICA in zero position
    plt.show()

    print ' '
    print 'nSims = ', nSims - 1
    print 'time interval 1: ', timeInterval1, 's, time interval 2: ', timeInterval2, 's'
    print '  => ', timeInterval1 / (nSims - 1), ' s/sim, ', timeInterval2 / (
        nSims - 1), ' s/sim'
    print 'SMICA optimized S_x: S = ',Ssmica,', for x = ',xValMinima[0], \
          ', with p-value ',PvalMinima[0]
    print ' '

    print 'step 3: profit'
    print ''
Ejemplo n.º 44
0
 def test_pixwin_pol(self):
     pixwin = hp.pixwin(128, pol=True)
     self.assertEqual(len(pixwin), 2)
Ejemplo n.º 45
0
    #theoretical power spectra.
    cl = qcinv.util.camb_clfile('inputs/wmap/bestfit_lensedCls.dat', lmax=lmax)
    
    # noise level
    # http://lambda.gsfc.nasa.gov/product/map/dr4/skymap_info.cfm
    ninv = hp.read_map("inputs/wmap/wmap_band_forered_iqumap_r9_7yr_V_v4.fits", field=3) / (3.137*1.0e3)**2
    assert( len(ninv) == npix )

    ncov  = np.zeros(npix)
    ncov[ np.where(ninv != 0) ] = 1.0 / ninv[ np.where(ninv != 0) ]

    assert( npix == len(ninv) )

    beam  = 0.5 * (np.loadtxt('inputs/wmap/wmap_ampl_bl_V1_7yr_v4.txt')[:,1][0:(lmax+1)] + np.loadtxt('inputs/wmap/wmap_ampl_bl_V2_7yr_v4.txt')[:,1][0:(lmax+1)])
    beam *= hp.pixwin(nside)[0:(lmax+1)]

    clnn  = np.sum(ncov) * (4.*np.pi) / npix**2 / beam**2

    ncov *= mask
    ninv *= mask

    # noise map
    print "generating noise map"
    nmap  = np.random.standard_normal(npix) * np.sqrt(ncov)

    # cmb map
    print "generating cmb map"
    tmap, talm = hp.synfast(cl.cltt * beam * beam, nside, lmax=lmax, alm=True)
    hp.almxfl(talm, 1.0/beam, inplace=True)
Ejemplo n.º 46
0
    def get_beam(self, det):
        pxw  = hp.pixwin(self.nside)[0:self.lmax+1]
        beam = dmc.get_bl(self.year, det)[0:self.lmax+1]

        return beam * pxw
Ejemplo n.º 47
0


lmax = len(cross_cls)
beam_lmax = lmax
l = np.arange(beam_lmax)
ll = l*(l+1)/(2*np.pi)
beam_14 = hp.gauss_beam(14.4*np.pi/(180.*60.),beam_lmax-1)
beam_5 = hp.gauss_beam(5.*np.pi/(180.*60.),beam_lmax-1)
b14_180 = hp.gauss_beam(np.sqrt((3*60.)**2 - (14.4)**2)*np.pi/(180.*60.),beam_lmax-1)
b5_180 = hp.gauss_beam(np.sqrt((3*60.)**2 - (5.)**2)*np.pi/(180.*60.),beam_lmax-1)

beam_14 *= (1. - b14_180)
beam_5 *= (1. - b5_180)

pix = hp.pixwin(256)[:beam_lmax]

theory_cls= hp.read_cl(theory_cl_file)
theory_cls=theory_cls[0][:beam_lmax]
#theory_cls[:2]=1e-10

cross_cls = cross_cls[:beam_lmax]
radio_cls = radio_cls[:beam_lmax]
cmb_cls = cmb_cls[:beam_lmax]

wls = hp.anafast((~radio_fr.mask).astype(float))[:beam_lmax]
fskyw2 = np.sum([(2*m+1)*wls[mi] if m > 0 else 0 for mi,m in enumerate(xrange(len(wls)))])/(4*np.pi)
wls = wls

fsky = 1. - np.sum(mask_bool).astype(float)/len(mask_bool)
L = np.sqrt(4*np.pi*fsky)
Ejemplo n.º 48
0
plot(lll,np.sqrt(abs(spectra[4])*(lll*(lll+1))/(2*np.pi)),label='$C_\ell^{TE}$')
plot(lll,np.sqrt(spectra[2]*(lll*(lll+1))/(2*np.pi)),label='$C_\ell^{EE}$')
plot(lll,np.sqrt(spectra[3]*(lll*(lll+1))/(2*np.pi)),label='$C_\ell^{BB}$')
yscale('log')
xlim(0,lmaxcamb+1)
ylim(0.0001,100)
xlabel('$\ell$')
ylabel('$\sqrt{\ell(\ell+1)C_\ell/(2\pi)}$'+'    '+'$[\mu K]$ ')
legend(loc='lower right',frameon=False)


#############################################################################
nside = 128
lmax = 2*nside-1
maps=hp.synfast(spectra[1:],nside,fwhm=0,pixwin=True,new=True)
pw = hp.pixwin(nside, pol=True)

lmax = 1*nside-1
cls1 = hp.anafast(maps,pol=True, lmax=lmax)
ell1= np.arange(lmax+1)
pw1 = [pw[0][0:lmax+1], pw[1][0:lmax+1]]

lmax = 2*nside-1
cls2 = hp.anafast(maps,pol=True, lmax=lmax)
ell2= np.arange(lmax+1)
pw2 = [pw[0][0:lmax+1], pw[1][0:lmax+1]]

lmax = 3*nside-1
cls3 = hp.anafast(maps,pol=True, lmax=lmax)
ell3= np.arange(lmax+1)
pw3 = [pw[0][0:lmax+1], pw[1][0:lmax+1]]
Ejemplo n.º 49
0
def covth_bins(ellbins,nside,ipok,bl,spectra,polar=True,temp=True,allinone=True):
    #### define bins in ell
    nbins=len(ellbins)-1
    minell=np.array(ellbins[0:nbins])
    maxell=np.array(ellbins[1:nbins+1])-1
    ellval=(minell+maxell)*0.5
    lmax=np.max(ellbins)
    #maxell[nbins-1]=lmax
    print('minell:',minell)
    print('maxell:',maxell)
    #### define Stokes
    all=['I','Q','U']
    if  not temp:
        all=['Q','U']
    if not polar:
        all=['I']

    #### define pixels
    print('rpix calculation')
    rpix=np.array(hp.pix2vec(nside,ipok))
    print('rpix done: ',rpix.shape)
    allcosang=np.dot(np.transpose(rpix),rpix)
    print('cosang done')
    
    #### define Pixel window function
    pixwin=hp.pixwin(nside)[0:lmax+1]

    #### get ell values from spectra and restrict spectra to good values
    nspec,nell=np.shape(spectra)
    ell=spectra[0]
    maskl=ell<(lmax+1)
    ell=ell[maskl]
    ctt=spectra[1][maskl]
    cee=spectra[2][maskl]
    cbb=spectra[3][maskl]
    cte=spectra[4][maskl]
    if nspec==5:
        print('Assuming EB and TB are zero')
        ceb=0
        ctb=0
    else:
        ceb=spectra[5][maskl]
        ctb=spectra[6][maskl]

    # Effective spectra
    print('Calculating effective spectra')
    norm=(2*ell+1)/(4*np.pi)*(pixwin**2)*(bl[maskl]**2)
    norm[1:]=norm[1:]/(ell[1:]*(ell[1:]+1))
    effctt=norm*ctt
    effcte=norm*cte
    effcee=norm*cee
    effcbb=norm*cbb
    effceb=norm*ceb
    effctb=norm*ctb

    #### define masks for ell bins
    masks=[]
    for i in np.arange(nbins):
        masks.append((ell>=minell[i]) & (ell<=maxell[i]))

    ### Create array for covariances matrices per bin
    nbpixok=ipok.size
    nstokes=np.size(all)
    print('creating array')
    cov=np.zeros((nbins,nstokes,nstokes,nbpixok,nbpixok))
    for i in np.arange(nbpixok):
        print(i)
        pyquad.progress_bar(i,nbpixok)
        for j in np.arange(i,nbpixok):
            if nstokes==1:
                pl=pl0(allcosang[i,j],lmax)
                TT=effctt*pl
                for b in np.arange(nbins):
                    cov[b,0,0,i,j]=np.sum(TT[masks[b]])*ellval[b]*(ellval[b]+1)
                    cov[b,0,0,j,i]=cov[b,0,0,i,j]
            if nstokes==2:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                for b in np.arange(nbins):
                    cov[b,0,0,i,j] = np.sum( cji*cQQpsQU[masks[b]] + sji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,0,j,i] = cov[b,0,0,i,j]
                    cov[b,0,1,i,j] = np.sum(-sji*cQQpsQU[masks[b]] + cji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,0,j,i] = cov[b,0,1,i,j]
                    cov[b,1,1,i,j] = np.sum(-sji*cQUmsQQ[masks[b]] + cji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,1,j,i] = cov[b,1,1,i,j]
                    cov[b,0,1,j,i] = np.sum( cji*cQUmsQQ[masks[b]] + sji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,0,i,j] = cov[b,0,1,j,i]
            if nstokes==3:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                pl=pl0(allcosang[i,j],lmax)
                f10=F1l0(allcosang[i,j],lmax)
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                TT=effctt*pl
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                TQ=-f10*effcte
                TU=-f10*effctb
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                for b in np.arange(nbins):
                    cov[b,0,0,i,j] = np.sum( TT[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,0,j,i] = cov[b,0,0,i,j]                
                    cov[b,0,1,i,j] = np.sum( cji*TQ[masks[b]] + sji*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,0,j,i] = cov[b,0,1,i,j]
                    cov[b,1,0,i,j] = np.sum( cij*TQ[masks[b]] + sij*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,1,j,i] = cov[b,1,0,i,j]
                    cov[b,0,2,i,j] = np.sum(-sji*TQ[masks[b]] + cij*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,2,0,j,i] = cov[b,0,2,i,j]
                    cov[b,2,0,i,j] = np.sum(-sij*TQ[masks[b]] + cij*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,2,j,i] = cov[b,2,0,i,j]
                    cov[b,1,1,i,j] = np.sum( cji*cQQpsQU[masks[b]] + sji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,1,j,i] = cov[b,1,1,i,j]
                    cov[b,1,2,i,j] = np.sum(-sji*cQQpsQU[masks[b]] + cji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,2,1,j,i] = cov[b,1,2,i,j]
                    cov[b,2,1,i,j] = np.sum( cji*cQUmsQQ[masks[b]] + sji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,2,j,i] = cov[b,2,1,i,j]
                    cov[b,2,2,i,j] = np.sum(-sji*cQUmsQQ[masks[b]] + cji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,2,2,j,i] = cov[b,2,2,i,j]
    if allinone:
        newcov=np.zeros((nbins,nstokes*nbpixok,nstokes*nbpixok))
        for i in np.arange(nbins):
            for si in np.arange(nstokes):
                for sj in np.arange(nstokes):
                    newcov[i,si*nbpixok:(si+1)*nbpixok,sj*nbpixok:(sj+1)*nbpixok]=cov[i,si,sj,:,:]
        return(newcov)
    else:
        return(cov)
Ejemplo n.º 50
0
 def pixfunc(self):
     if self._pixfunc is None:
         self._pixfunc = hp.pixwin(self.nside, pol=False)[:self.lmax]
     return self._pixfunc
Ejemplo n.º 51
0
    # add noise
    map=mapin.copy()
    map[mask]+=np.random.randn(npix)*signoise
    allmaps[:,i]=map[mask]
    allmaps_nosig[:,i]=map[mask]-mapin[mask]
    
mcl=np.zeros(251)
for i in arange(251):
    mcl[i]=np.mean(allcl[i,:])

clf()
plot(ell,spectra[1]*(ell*(ell+1))/(2*np.pi),'r')
xlim(0,251)
thel=np.arange(251)
thebell=np.exp(-0.5*(thel**2)*((fwhm/2.35)**2))
pixwin=hp.pixwin(hp.npix2nside(len(mapin)))[0:251]
plot(thel,mcl*thel*(thel+1)/(2*np.pi)/thebell**2/pixwin**2)



covmc=np.zeros((npix,npix))
covmc_nonoise=np.zeros((npix,npix))
covmc_nosig=np.zeros((npix,npix))
for i in np.arange(npix):
    print(i)
    for j in np.arange(i,npix):
        covmc[i,j]=mean( (allmaps[i,:]-mean(allmaps[i,:]))*(allmaps[j,:]-mean(allmaps[j,:])))
        covmc_nonoise[i,j]=mean( (allmaps_nonoise[i,:]-mean(allmaps_nonoise[i,:]))*(allmaps_nonoise[j,:]-mean(allmaps_nonoise[j,:])))
        covmc_nosig[i,j]=mean( (allmaps_nosig[i,:]-mean(allmaps_nosig[i,:]))*(allmaps_nosig[j,:]-mean(allmaps_nosig[j,:])))
        covmc[j,i]=covmc[i,j]
        covmc_nosig[j,i]=covmc_nosig[i,j]
Ejemplo n.º 52
0
def fix_for_mask(config, logger=log.null_logger):
    with log.Timer(logger,
                   'Step 4: Accounting for mask').with_level(logging.INFO):
        coupling_matrix_fname = config.get('mask_coupling_matrix_fname')

        # If the coupling matrix is not specified, we need to make it
        if not coupling_matrix_fname:
            output_file = os.path.join(config['output_dir'],
                                       'master_deconv_spectra.fits')

            maxl = config.get('matmask_maxl', 2500)

            # mrsp_matmask -t -w -v -z -l 1024 -o TQU <smap> <mask> <output_file>
            cmd = [
                matmask_command, '-t', '-w', '-v', '-z', '-l',
                str(maxl), '-o', 'TQU', config['aggregated_map_fname'],
                config['mask_fname'], output_file
            ]

            rc = log.run_command(cmd, timeout=5e-2, logger=logger)

            if rc != 0:
                raise RuntimeError(matmask_command +
                                   ' failed with exit code: ' + str(rc))

            # Outputs are:
            # master_deconv_spectra.fits
            # master_deconv_spectra_maskedmap_pspec.fits
            # master_deconv_spectra_mask_pspec.fits
            # master_deconv_spectra_mask_spec_radii.fits
            # master_deconv_spectra_coupling_matrices.fits
            if config.get('delete_tmps', True):
                tmps = [
                    os.path.join(config['output_dir'], fname) for fname in (
                        'master_deconv_spectra.fits',
                        'master_deconv_spectra_maskedmap_pspec.fits',
                        'master_deconv_spectra_mask_pspec.fits',
                        'master_deconv_spectra_mask_spec_radii.fits',
                        'master_deconv_spectra_coupling_matrices.fits')
                ]
                for tmp in tmps:
                    logger.debug('deleting ' + tmp)
                    os.remove(tmp)

            coupling_matrix_fname = os.path.join(
                config['output_dir'],
                'master_deconv_spectra_coupling_matrices.fits')

        coupling_matrix = fitsio.FITS(coupling_matrix_fname)[0].read()

        # FIXME: mrsp_matmask does not produce the correct spectrum, but it does
        # produce the correct coupling matrix. we can use the coupling matrix
        # and invert it ourselves.
        # TODO: get to the bottom of this. Why does mrsp_matmask give the wrong
        # answers? Can Florent or JLS figure this out?
        mask = hp.read_map(config['mask_fname'], verbose=False)
        aggregated_cmb = hp.read_map(config['aggregated_map_fname'],
                                     verbose=False)
        # 1e6 to convert K -> mu K
        masked_powerspec = hp.anafast(mask * 1e6 * aggregated_cmb,
                                      lmax=coupling_matrix.shape[0] - 1)
        recovered_pspec = np.linalg.solve(coupling_matrix, masked_powerspec)
        ells = np.arange(recovered_pspec.size)
        ll1 = ells * (ells + 1) / (2 * np.pi) / hp.pixwin(
            2048, lmax=ells.size - 1)**2
        hp.write_cl(
            os.path.join(config['output_dir'], 'mask_corrected_spectra.fits'),
            ll1 * recovered_pspec)
Ejemplo n.º 53
0
	clnoiseless[j,:,:] = np.mean(allclnoiseless, axis = 2)
	dclnoiseless[j,:,:] = np.std(allclnoiseless, axis = 2)
	clnoisy[j,:,:] = np.mean(allclnoisy, axis = 2)
	dclnoisy[j,:,:] = np.std(allclnoisy, axis = 2)
	clres[j,:,:] = np.mean(allclres, axis = 2)
	dclres[j,:,:] = np.std(allclres, axis = 2)
	clspoiled_noiseless[j,:,:] = np.mean(allclspoiled_noiseless, axis = 2)
	dclspoiled_noiseless[j,:,:] = np.std(allclspoiled_noiseless, axis = 2)
	clspoiled_noisy[j,:,:] = np.mean(allclspoiled_noisy, axis = 2)
	dclspoiled_noisy[j,:,:] = np.std(allclspoiled_noisy, axis = 2)
	clspoiled_res[j,:,:] = np.mean(allclspoiled_res, axis = 2)
	dclspoiled_res[j,:,:] = np.std(allclspoiled_res, axis = 2)


#### Pixel Window function
wpix = hp.pixwin(ns,pol=True)
#### Synthesized Beam window function
fwhm = 0.47
ll = np.arange(len(wpix[0]))
bl = exp(-ll**2*(np.radians(fwhm/2.35))**2/2)
#### Correction
corrT = np.interp(newl, ll, wpix[0]**2*bl**2)
corrP = np.interp(newl, ll, wpix[1]**2*bl**2)
corr=corrT

cl = clinit
col = ['black','red', 'blue', 'green', 'magenta']
clf()
for i in np.arange(len(sigptgvals)):
	for j in np.arange(6):
		subplot(2,3,j+1)	
Ejemplo n.º 54
0
def plot_mc():

	f=open('cl_theory_FR_QxaU.json','r')
	theory1_array_in=json.load(f)
	f.close()	
	f=open('cl_theory_FR_UxaQ.json','r')
	theory2_array_in=json.load(f)
	f.close()	
	f=open('cl_array_FR_QxaU.json','r')
	cross1_array_in=json.load(f)
	f.close()	
	f=open('cl_array_FR_UxaQ.json','r')
	cross2_array_in=json.load(f)
	f.close()	
#	f=open('cl_noise_FR_QxaU.json','r')
#	noise1_array_in=json.load(f)
#	f.close()	
#	f=open('cl_noise_FR_UxaQ.json','r')
#	noise2_array_in=json.load(f)
#	f.close()	
	f=open('cl_Nau_FR_QxaU.json','r')
	Nau_array_in=json.load(f)
	f.close()	
	f=open('cl_Ndq_FR_QxaU.json','r')
	Ndq_array_in=json.load(f)
	f.close()	
	f=open('cl_Naq_FR_UxaQ.json','r')
	Naq_array_in=json.load(f)
	f.close()	
	f=open('cl_Ndu_FR_UxaQ.json','r')
	Ndu_array_in=json.load(f)
	f.close()	
	
	bins=[1,5,10,20,25,50]
	N_runs=500
#	bls=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),383)**2
	#bls=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)**2
	bls=(hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)*hp.pixwin(nside_out)[:3*nside_out])**2
	#bls=np.repeat(1,3*nside_out)
	fsky=225.*(np.pi/180.)**2/(4*np.pi)
	l=np.arange(len(cross1_array_in[0]))
	ll=l*(l+1)/(2*np.pi)
	L=np.sqrt(fsky*4*np.pi)
	dl_eff=2*np.pi/L

        theory1_array_in=np.array(theory1_array_in)/(fsky*bls)
	theory2_array_in=np.array(theory2_array_in)/(fsky*bls)
	cross1_array_in=np.array(cross1_array_in)/(fsky*bls)
	cross2_array_in=np.array(cross2_array_in)/(fsky*bls)
	Ndq_array_in=np.array(Ndq_array_in)/(fsky)
	Ndu_array_in=np.array(Ndu_array_in)/(fsky)
	Nau_array_in=np.array(Nau_array_in)/(fsky)
	Naq_array_in=np.array(Naq_array_in)/(fsky)
	#noise1_array_in=np.array(noise1_array_in)/(fsky*bls)
	#noise2_array_in=np.array(noise2_array_in)/(fsky*bls)

	Ndq_array_in.shape += (1,)
	Ndu_array_in.shape += (1,)
	Nau_array_in.shape += (1,)
	Naq_array_in.shape += (1,)


	for b in bins:
		theory_cls=hp.read_cl('/home/matt/Planck/data/faraday/correlation/fr_theory_cl.fits')
	#	N_dq=np.mean(Ndq_array_in)
	#	N_au=np.mean(Nau_array_in)
	#	#delta1=np.sqrt(2.*abs((np.mean(cross1_array_in,axis=0)-np.mean(noise1_array_in,axis=0))**2+(np.mean(cross1_array_in,axis=0)-np.mean(noise1_array_in,axis=0))/2.*(N_dq+N_au)+N_dq*N_au/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
	#	delta1=np.sqrt(2.*((np.mean(theory1_array_in,axis=0))**2+(np.mean(theory1_array_in,axis=0))/2.*(N_dq+N_au)+N_dq*N_au/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
	#
		cosmic1=np.sqrt(2./((2.*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory1_array_in,axis=0)**2)

	#	N_du=np.mean(Ndu_array_in)
	#	N_aq=np.mean(Naq_array_in)
	#	#delta2=np.sqrt(2.*abs((np.mean(cross2_array_in,axis=0)-np.mean(noise2_array_in,axis=0))**2+(np.mean(cross2_array_in,axis=0)-np.mean(noise2_array_in,axis=0))/2.*(N_dq+N_au)+N_dq*N_au/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
	#	delta2=np.sqrt(2.*((np.mean(theory2_array_in,axis=0))**2+(np.mean(theory2_array_in,axis=0))/2.*(N_du+N_aq)+N_du*N_aq/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
		cosmic2=np.sqrt(2./((2*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory2_array_in,axis=0)**2)

        	theory1_array=[]
        	theory2_array=[]
        	cross1_array=[]
        	cross2_array=[]
        #	noise1_array=[]
        #	noise2_array=[]
                    	
            	Ndq_array=[]
        	Ndu_array=[]
        	Nau_array=[]
        	Naq_array=[]
        	
		plot_l=[]
		if( b != 1):
	        	tmp_t1=bin_llcl.bin_llcl(ll*theory1_array_in,b)
	        	tmp_t2=bin_llcl.bin_llcl(ll*theory2_array_in,b)
			tmp_c1=bin_llcl.bin_llcl(ll*cross1_array_in,b)
	        	tmp_c2=bin_llcl.bin_llcl(ll*cross2_array_in,b)
		#	tmp_n1=bin_llcl.bin_llcl(ll*noise1_array_in,b)
	        #	tmp_n2=bin_llcl.bin_llcl(ll*noise2_array_in,b)
	        	
			theory1_array=tmp_t1['llcl']
			theory2_array=tmp_t2['llcl']
                        theory1_array.shape += (1,)
                        theory2_array.shape += (1,)
                        theory1_array=theory1_array.T
                        theory2_array=theory2_array.T
			plot_l= tmp_t1['l_out']
			cross1_array=tmp_c1['llcl']
			cross2_array=tmp_c2['llcl']
			
		#	noise1_array=tmp_n1['llcl']
		#	noise2_array=tmp_n2['llcl']
	        	
			Ndq_array=bin_llcl.bin_llcl(ll*Ndq_array_in,b)['llcl']
			Ndu_array=bin_llcl.bin_llcl(ll*Ndu_array_in,b)['llcl']
			Naq_array=bin_llcl.bin_llcl(ll*Naq_array_in,b)['llcl']
			Nau_array=bin_llcl.bin_llcl(ll*Nau_array_in,b)['llcl']
			tmp_c1=bin_llcl.bin_llcl((ll*cosmic1)**2,b)
			#tmp_d1=bin_llcl.bin_llcl((ll*delta1)**2,b)
		
			cosmic1=np.sqrt(tmp_c1['llcl'])
			#delta1=np.sqrt(tmp_d1['llcl'])

			tmp_c2=bin_llcl.bin_llcl((ll*cosmic2)**2,b)
			#tmp_d2=bin_llcl.bin_llcl((ll*delta2)**2,b)
			cosmic2=np.sqrt(tmp_c2['llcl'])
			#delta2=np.sqrt(tmp_d2['llcl'])
			t_tmp=bin_llcl.bin_llcl(ll*theory_cls,b)
			theory_cls=t_tmp['llcl']
		else:
			plot_l=l
			theory1_array=np.multiply(ll,theory1_array_in)
			cross1_array=np.multiply(ll,cross1_array_in)
		#	noise1_array=np.multiply(ll,noise1_array_in)
			theory2_array=np.multiply(ll,theory2_array_in)
			cross2_array=np.multiply(ll,cross2_array_in)
		#	noise2_array=np.multiply(ll,noise2_array_in)
			cosmic1*=ll
			cosmic2*=ll
			#delta1*=ll
			#delta2*=ll
			Ndq_array=np.multiply(ll,Ndq_array_in)
			Ndu_array=np.multiply(ll,Ndu_array_in)
			Naq_array=np.multiply(ll,Naq_array_in)
			Nau_array=np.multiply(ll,Nau_array_in)
			theory_cls*=ll
		#ipdb.set_trace()
		bad=np.where(plot_l < 24)
		N_dq=np.mean(Ndq_array,axis=0)
		N_du=np.mean(Ndu_array,axis=0)
		N_aq=np.mean(Naq_array,axis=0)
		N_au=np.mean(Nau_array,axis=0)
		#noise1=np.mean(noise1_array,axis=0)
		#noise2=np.mean(noise2_array,axis=0)
		theory1=np.mean(theory1_array,axis=0)
		theory2=np.mean(theory1_array,axis=0)
        	theory_array = np.add(theory1_array,theory2_array)
        	theory=np.mean(theory_array,axis=0)
        	#dtheory=np.sqrt(np.var(theory1_array,ddof=1) + np.var(theory2_array,ddof=1))
        	#cross_array = np.add(np.subtract(cross1_array,noise1),np.subtract(cross2_array,noise2))
        	cross_array = np.add(cross1_array,cross2_array)
        	cross=np.mean(cross_array,axis=0)
        	#dcross=np.std(cross_array,axis=0,ddof=1)
        	dcross=np.sqrt( ( np.var(cross1_array,axis=0,ddof=1) + np.var(cross2_array,axis=0,ddof=1)))
        	cosmic=np.sqrt(cosmic1**2+cosmic2**2)
	
		delta1=np.sqrt(2./((2*plot_l+1)*fsky*np.sqrt(b**2+dl_eff**2))*(theory1**2 + theory1*(N_dq+N_au)/2. + N_dq*N_au/2.))
		delta2=np.sqrt(2./((2*plot_l+1)*fsky*np.sqrt(b**2+dl_eff**2))*(theory2**2 + theory2*(N_du+N_aq)/2. + N_du*N_aq/2.))
        	delta=np.sqrt(delta1**2+delta2**2)
		#cosmic=np.abs(theory_cls)*np.sqrt(2./((2*plot_l+1)*fsky*np.sqrt(dl_eff**2+b**2)))
		#theory1=np.mean(theory1_array,axis=0)
		#dtheory1=np.std(theory1_array,axis=0,ddof=1)
		#cross1=np.mean(cross1_array,axis=0)
		#dcross1=np.std(np.subtract(cross1_array,noise1),axis=0,ddof=1)
		#ipdb.set_trace()
                good_l=np.logical_and(plot_l <= 250,plot_l >25)
		plot_binned.plotBinned((cross)*1e12,dcross*1e12,plot_l,b,'Cross_43x95_FR', title='QUIET FR Correlator',theory=theory*1e12,delta=delta*1e12,cosmic=cosmic*1e12)

		#theory2=np.mean(theory2_array,axis=0)
		#dtheory2=np.std(theory2_array,axis=0,ddof=1)
		#cross2=np.mean(cross2_array,axis=0)
		##delta2=np.mean(delta2_array,axis=0)
		#dcross2=np.std(np.subtract(cross2_array,noise2),axis=0,ddof=1)
		##ipdb.set_trace()
		#plot_binned.plotBinned((cross2-noise2)*1e12,dcross2*1e12,plot_l,b,'Cross_43x95_FR_UxaQ', title='Cross 43x95 FR UxaQ',theory=theory2*1e12,dtheory=dtheory2*1e12,delta=delta2*1e12,cosmic=cosmic2*1e12)
		#ipdb.set_trace()
    
		if b == 25 :
                        good_l=np.logical_and(plot_l <= 250,plot_l >25)
			likelihood(cross[good_l],delta[good_l],theory[good_l],'field1','c2bfr')

		#if b == 1 :
		#	xbar= np.matrix(ll[1:]*(cross-np.mean(cross))[1:]).T
		#	vector=np.matrix(ll[1:]*cross[1:]).T
		#	mu=np.matrix(ll[1:]*theory[1:]).T
		#	fact=len(xbar)-1
		#	cov=(np.dot(xbar,xbar.T)/fact).squeeze()
		##	ipdb.set_trace()
		#	U,S,V =np.linalg.svd(cov)
		#	_cov= np.einsum('ij,j,jk', V.T,1./S,U.T)
		#	likelhd=np.exp(-np.dot(np.dot((vector-mu).T,_cov),(vector-mu))/2. )/(np.sqrt(2*np.pi*np.prod(S)))
		##	print('Likelihood of fit is #{0:.5f}'.format(likelihood[0,0]))
		#	f=open('FR_likelihood.txt','w')
		#	f.write('Likelihood of fit is #{0:.5f}'.format(likelhd[0,0]))
		#	f.close()

	subprocess.call('mv *01*.png bin_01/', shell=True)
	subprocess.call('mv *05*.png bin_05/', shell=True)
	subprocess.call('mv *10*.png bin_10/', shell=True)
	subprocess.call('mv *20*.png bin_20/', shell=True)
	subprocess.call('mv *25*.png bin_25/', shell=True)
	subprocess.call('mv *50*.png bin_50/', shell=True)
	subprocess.call('mv *.eps eps/', shell=True)
Ejemplo n.º 55
0
 def test_pixwin_pol(self):
     pixwin = hp.pixwin(128, pol=True)
     self.assertEqual(len(pixwin), 2)
Ejemplo n.º 56
0
def main():
	##Parameters for Binning, Number of Runs
	##	Beam correction
	use_beam=0
#	bls=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),383)**2
	#bls=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)**2
	bls=(hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)*hp.pixwin(nside_out)[:3*nside_out])**2
	N_runs=500
	bins=[1,5,10,20,50]

	map_prefix='/home/matt/quiet/quiet_maps/'
	i_file=map_prefix+'quiet_simulated_43.1'
	j_file=map_prefix+'quiet_simulated_94.5'
	alpha_file='/data/wmap/faraday_MW_realdata.fits'
	bands=[43.1,94.5]
	names=['43','95']
	wl=np.array([299792458./(band*1e9) for band in bands])
	cross1_array_in=[]
	cross2_array_in=[]
	Ndq_array_in=[]
	Ndu_array_in=[]
	Nau_array_in=[]
	Naq_array_in=[]
	noise1_array_in=[]
	noise2_array_in=[]
	theory1_array_in=[]
	theory2_array_in=[]
	

	#simulate_fields.main()
	ttmp1,ttmp2=faraday_theory_quiet(i_file+'.fits',j_file+'.fits',wl[0],wl[1],alpha_file,names[0]+'x'+names[1],beam=use_beam)
	theory1_array_in.append(ttmp1)
	theory2_array_in.append(ttmp2)
	#for n in xrange(N_runs):
	for i in xrange(N_runs):	
		print(Fore.WHITE+Back.GREEN+Style.BRIGHT+'Correlation #{:03d}'.format(i+1)+Back.RESET+Fore.RESET+Style.RESET_ALL)
		tmp1,tmp2,n1,n2,n3,n4=faraday_correlate_quiet(i_file+'.fits',j_file+'.fits',wl[0],wl[1],alpha_file,names[0]+'x'+names[1],beam=use_beam)
	#	ntmp1,ntmp2=faraday_noise_quiet(i_file+'.fits',j_file+'.fits',wl[0],wl[1],alpha_file,names[0]+'x'+names[1],beam=use_beam)
		cross1_array_in.append(tmp1)
		cross2_array_in.append(tmp2)
		Ndq_array_in.append(n1)
		Ndu_array_in.append(n2)
		Nau_array_in.append(n3)
		Naq_array_in.append(n4)
	#	noise1_array_in.append(ntmp1)
	#	noise2_array_in.append(ntmp2)


	f=open('cl_theory_FR_QxaU.json','w')
	json.dump(np.array(theory1_array_in).tolist(),f)
	f.close()	
	f=open('cl_theory_FR_UxaQ.json','w')
	json.dump(np.array(theory2_array_in).tolist(),f)
	f.close()	
	theory1=np.mean(theory1_array_in,axis=0)
	theory2=np.mean(theory2_array_in,axis=0)
	hp.write_cl('cl_theory_FR_QxaU.fits',theory1)
	hp.write_cl('cl_theory_FR_UxaQ.fits',theory2)
	#f=open('cl_theory_FR_QxaU.json','r')
	#theory1_array=json.load(f)
	#f.close()	
	#f=open('cl_theory_FR_UxaQ.json','r')
	#theory2_array=json.load(f)
	#f.close()	
	f=open('cl_array_FR_QxaU.json','w')
	json.dump(np.array(cross1_array_in).tolist(),f)
	f.close()	
	f=open('cl_array_FR_UxaQ.json','w')
	json.dump(np.array(cross2_array_in).tolist(),f)
	f.close()	
	f=open('cl_Ndq_FR_QxaU.json','w')
	json.dump(np.array(Ndq_array_in).tolist(),f)
	f.close()	
	f=open('cl_Ndu_FR_UxaQ.json','w')
	json.dump(np.array(Ndu_array_in).tolist(),f)
	f.close()	
	f=open('cl_Nau_FR_QxaU.json','w')
	json.dump(np.array(Nau_array_in).tolist(),f)
	f.close()	
	f=open('cl_Naq_FR_UxaQ.json','w')
	json.dump(np.array(Naq_array_in).tolist(),f)
	f.close()	
	#f=open('cl_noise_FR_QxaU.json','w')
	#json.dump(np.array(noise1_array_in).tolist(),f)
	#f.close()	
	#f=open('cl_noise_FR_UxaQ.json','w')
	#json.dump(np.array(noise2_array_in).tolist(),f)
	#f.close()	
	bins=[1,5,10,20,25,50]
	fsky=225.*(np.pi/180.)**2/(4*np.pi)
	l=np.arange(len(cross1_array_in[0]))
	ll=l*(l+1)/(2*np.pi)
	L=np.sqrt(fsky*4*np.pi)
	dl_eff=2*np.pi/L
	
        theory1_array_in=np.array(theory1_array_in)/(fsky*bls)
	theory2_array_in=np.array(theory2_array_in)/(fsky*bls)
	cross1_array_in=np.array(cross1_array_in)/(fsky*bls)
	cross2_array_in=np.array(cross2_array_in)/(fsky*bls)
	Ndq_array_in=np.array(Ndq_array_in)/(fsky)
	Ndu_array_in=np.array(Ndu_array_in)/(fsky)
	Nau_array_in=np.array(Nau_array_in)/(fsky)
	Naq_array_in=np.array(Naq_array_in)/(fsky)
	#noise1_array_in=np.array(noise1_array_in)/(fsky*bls)
	#noise2_array_in=np.array(noise2_array_in)/(fsky*bls)

	Ndq_array_in.shape += (1,)
	Ndu_array_in.shape += (1,)
	Nau_array_in.shape += (1,)
	Naq_array_in.shape += (1,)


	for b in bins:
		theory_cls=hp.read_cl('/home/matt/Planck/data/faraday/correlation/fr_theory_cl.fits')
	#	N_dq=np.mean(Ndq_array_in)
	#	N_au=np.mean(Nau_array_in)
	#	#delta1=np.sqrt(2.*abs((np.mean(cross1_array_in,axis=0)-np.mean(noise1_array_in,axis=0))**2+(np.mean(cross1_array_in,axis=0)-np.mean(noise1_array_in,axis=0))/2.*(N_dq+N_au)+N_dq*N_au/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
	#	delta1=np.sqrt(2.*((np.mean(theory1_array_in,axis=0))**2+(np.mean(theory1_array_in,axis=0))/2.*(N_dq+N_au)+N_dq*N_au/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
	#
		cosmic1=np.sqrt(2./((2.*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory1_array_in,axis=0)**2)

	#	N_du=np.mean(Ndu_array_in)
	#	N_aq=np.mean(Naq_array_in)
	#	#delta2=np.sqrt(2.*abs((np.mean(cross2_array_in,axis=0)-np.mean(noise2_array_in,axis=0))**2+(np.mean(cross2_array_in,axis=0)-np.mean(noise2_array_in,axis=0))/2.*(N_dq+N_au)+N_dq*N_au/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
	#	delta2=np.sqrt(2.*((np.mean(theory2_array_in,axis=0))**2+(np.mean(theory2_array_in,axis=0))/2.*(N_du+N_aq)+N_du*N_aq/2.)/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky))
		cosmic2=np.sqrt(2./((2*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory2_array_in,axis=0)**2)

        	theory1_array=[]
        	theory2_array=[]
        	cross1_array=[]
        	cross2_array=[]
        #	noise1_array=[]
        #	noise2_array=[]
                    	
            	Ndq_array=[]
        	Ndu_array=[]
        	Nau_array=[]
        	Naq_array=[]
        	
		plot_l=[]
		if( b != 1):
	        	tmp_t1=bin_llcl.bin_llcl(ll*theory1_array_in,b)
	        	tmp_t2=bin_llcl.bin_llcl(ll*theory2_array_in,b)
			tmp_c1=bin_llcl.bin_llcl(ll*cross1_array_in,b)
	        	tmp_c2=bin_llcl.bin_llcl(ll*cross2_array_in,b)
		#	tmp_n1=bin_llcl.bin_llcl(ll*noise1_array_in,b)
	        #	tmp_n2=bin_llcl.bin_llcl(ll*noise2_array_in,b)
	        	
			theory1_array=tmp_t1['llcl']
			theory2_array=tmp_t2['llcl']
                        theory1_array.shape += (1,)
                        theory2_array.shape += (1,)
                        theory1_array=theory1_array.T
                        theory2_array=theory2_array.T
			plot_l= tmp_t1['l_out']
			cross1_array=tmp_c1['llcl']
			cross2_array=tmp_c2['llcl']
			
		#	noise1_array=tmp_n1['llcl']
		#	noise2_array=tmp_n2['llcl']
	        	
			Ndq_array=bin_llcl.bin_llcl(ll*Ndq_array_in,b)['llcl']
			Ndu_array=bin_llcl.bin_llcl(ll*Ndu_array_in,b)['llcl']
			Naq_array=bin_llcl.bin_llcl(ll*Naq_array_in,b)['llcl']
			Nau_array=bin_llcl.bin_llcl(ll*Nau_array_in,b)['llcl']
			tmp_c1=bin_llcl.bin_llcl((ll*cosmic1)**2,b)
			#tmp_d1=bin_llcl.bin_llcl((ll*delta1)**2,b)
		
			cosmic1=np.sqrt(tmp_c1['llcl'])
			#delta1=np.sqrt(tmp_d1['llcl'])

			tmp_c2=bin_llcl.bin_llcl((ll*cosmic2)**2,b)
			#tmp_d2=bin_llcl.bin_llcl((ll*delta2)**2,b)
			cosmic2=np.sqrt(tmp_c2['llcl'])
			#delta2=np.sqrt(tmp_d2['llcl'])
			t_tmp=bin_llcl.bin_llcl(ll*theory_cls,b)
			theory_cls=t_tmp['llcl']
		else:
			plot_l=l
			theory1_array=np.multiply(ll,theory1_array_in)
			cross1_array=np.multiply(ll,cross1_array_in)
		#	noise1_array=np.multiply(ll,noise1_array_in)
			theory2_array=np.multiply(ll,theory2_array_in)
			cross2_array=np.multiply(ll,cross2_array_in)
		#	noise2_array=np.multiply(ll,noise2_array_in)
			cosmic1*=ll
			cosmic2*=ll
			#delta1*=ll
			#delta2*=ll
			Ndq_array=np.multiply(ll,Ndq_array_in)
			Ndu_array=np.multiply(ll,Ndu_array_in)
			Naq_array=np.multiply(ll,Naq_array_in)
			Nau_array=np.multiply(ll,Nau_array_in)
			theory_cls*=ll
		#ipdb.set_trace()
		bad=np.where(plot_l < 24)
		N_dq=np.mean(Ndq_array,axis=0)
		N_du=np.mean(Ndu_array,axis=0)
		N_aq=np.mean(Naq_array,axis=0)
		N_au=np.mean(Nau_array,axis=0)
		#noise1=np.mean(noise1_array,axis=0)
		#noise2=np.mean(noise2_array,axis=0)
		theory1=np.mean(theory1_array,axis=0)
		theory2=np.mean(theory1_array,axis=0)
        	theory_array = np.add(theory1_array,theory2_array)
        	theory=np.mean(theory_array,axis=0)
        	#dtheory=np.sqrt(np.var(theory1_array,ddof=1) + np.var(theory2_array,ddof=1))
        	#cross_array = np.add(np.subtract(cross1_array,noise1),np.subtract(cross2_array,noise2))
        	cross_array = np.add(cross1_array,cross2_array)
        	cross=np.mean(cross_array,axis=0)
        	#dcross=np.std(cross_array,axis=0,ddof=1)
        	dcross=np.sqrt( ( np.var(cross1_array,axis=0,ddof=1) + np.var(cross2_array,axis=0,ddof=1)))
        	cosmic=np.sqrt(cosmic1**2+cosmic2**2)
	
		delta1=np.sqrt(2./((2*plot_l+1)*fsky*np.sqrt(b**2+dl_eff**2))*(theory1**2 + theory1*(N_dq+N_au)/2. + N_dq*N_au/2.))
		delta2=np.sqrt(2./((2*plot_l+1)*fsky*np.sqrt(b**2+dl_eff**2))*(theory2**2 + theory2*(N_du+N_aq)/2. + N_du*N_aq/2.))
        	delta=np.sqrt(delta1**2+delta2**2)
		#cosmic=np.abs(theory_cls)*np.sqrt(2./((2*plot_l+1)*fsky*np.sqrt(dl_eff**2+b**2)))
		#theory1=np.mean(theory1_array,axis=0)
		#dtheory1=np.std(theory1_array,axis=0,ddof=1)
		#cross1=np.mean(cross1_array,axis=0)
		#dcross1=np.std(np.subtract(cross1_array,noise1),axis=0,ddof=1)
		#ipdb.set_trace()
		plot_binned.plotBinned((cross)*1e12,dcross*1e12,plot_l,b,'Cross_43x95_FR', title='QUIET FR Correlator',theory=theory*1e12,delta=delta*1e12,cosmic=cosmic*1e12)

		#theory2=np.mean(theory2_array,axis=0)
		#dtheory2=np.std(theory2_array,axis=0,ddof=1)
		#cross2=np.mean(cross2_array,axis=0)
		##delta2=np.mean(delta2_array,axis=0)
		#dcross2=np.std(np.subtract(cross2_array,noise2),axis=0,ddof=1)
		##ipdb.set_trace()
		#plot_binned.plotBinned((cross2-noise2)*1e12,dcross2*1e12,plot_l,b,'Cross_43x95_FR_UxaQ', title='Cross 43x95 FR UxaQ',theory=theory2*1e12,dtheory=dtheory2*1e12,delta=delta2*1e12,cosmic=cosmic2*1e12)
		#ipdb.set_trace()
    
		if b == 25 :
                        good_l=np.logical_and(plot_l <= 200,plot_l >25)
			likelihood(cross[good_l],delta[good_l],theory[good_l],'field1','c2bfr')

		#if b == 1 :
		#	xbar= np.matrix(ll[1:]*(cross-np.mean(cross))[1:]).T
		#	vector=np.matrix(ll[1:]*cross[1:]).T
		#	mu=np.matrix(ll[1:]*theory[1:]).T
		#	fact=len(xbar)-1
		#	cov=(np.dot(xbar,xbar.T)/fact).squeeze()
		##	ipdb.set_trace()
		#	U,S,V =np.linalg.svd(cov)
		#	_cov= np.einsum('ij,j,jk', V.T,1./S,U.T)
		#	likelhd=np.exp(-np.dot(np.dot((vector-mu).T,_cov),(vector-mu))/2. )/(np.sqrt(2*np.pi*np.prod(S)))
		##	print('Likelihood of fit is #{0:.5f}'.format(likelihood[0,0]))
		#	f=open('FR_likelihood.txt','w')
		#	f.write('Likelihood of fit is #{0:.5f}'.format(likelhd[0,0]))
		#	f.close()

	subprocess.call('mv *01*.png bin_01/', shell=True)
	subprocess.call('mv *05*.png bin_05/', shell=True)
	subprocess.call('mv *10*.png bin_10/', shell=True)
	subprocess.call('mv *20*.png bin_20/', shell=True)
	subprocess.call('mv *25*.png bin_25/', shell=True)
	subprocess.call('mv *50*.png bin_50/', shell=True)
	subprocess.call('mv *.eps eps/', shell=True)
def getSMICA(theta_i=0.0,
             theta_f=180.0,
             nSteps=1800,
             lmax=100,
             lmin=2,
             newSMICA=False,
             useSPICE=True,
             newDeg=False,
             R1=False):
    """
  Purpose:
    load CMB and mask maps from files, return correlation function for
    unmasked and masked CMB
    Mostly follows Copi et. al. 2013 for cut sky C(theta)
  Uses:
    get_crosspower.py (for plotting)
    C(theta) save file getSMICAfile.npy
  Inputs:
    theta_i,theta_f: starting and ending points for C(theta) in degrees
    nSteps: number of intervals between i,f points
    lmax: the maximum l value to include in legendre series for C(theta)
    lmin: the lowest l to use in C(theta,Cl) and S_{1/2} = CIC calculation
    newSMICA: set to True to reload data from files and recompute
      if False, will load C(theta) curves from file
    useSPICE: if True, will use SPICE to find power spectra
      if False, will use anafast, following Copi et. al. 2013
      Default: True
    newDeg: set to True to recalculate map and mask degredations
      Note: the saved files are dependent on the value of lmax that was used
      Default: False
    R1: set to True to use R1 versions of SMICA and mask.  Otherwise, R2 is used
      Only affects which Planck files are used; irrelevant if newDeg=False.
      Default: False
  Outupts:
    theta: nSteps+1 angles that C(theta) arrays are for (degrees)
    unmasked: C(theta) unmasked (microK^2)
    masked: C(theta) masked     (microK^2)

  """
    saveFile = 'getSMICAfile.npy'  #for anafast
    saveFile2 = 'getSMICAfile2.npy'  #for spice
    if newSMICA:
        # start with map degredations
        mapDegFile = 'smicaMapDeg.fits'
        maskDegFile = 'maskMapDeg.fits'
        if newDeg:
            # load maps; default files have 2048,NESTED,GALACTIC
            dataDir = '/Data/'
            if R1:
                smicaFile = 'COM_CompMap_CMB-smica-field-I_2048_R1.20.fits'
                maskFile = 'COM_Mask_CMB-union_2048_R1.10.fits'
            else:
                smicaFile = 'COM_CMB_IQU-smica-field-int_2048_R2.01_full.fits'
                maskFile = 'COM_CMB_IQU-common-field-MaskInt_2048_R2.01.fits'
            print 'opening file ', smicaFile, '... '
            smicaMap, smicaHead = hp.read_map(dataDir + smicaFile,
                                              nest=True,
                                              h=True)
            print 'opening file ', maskFile, '... '
            maskMap, maskHead = hp.read_map(dataDir + maskFile,
                                            nest=True,
                                            h=True)
            if R1:
                smicaMap *= 1e-6  #microK to K

            # degrade map and mask resolutions from 2048 to 128; convert NESTED to RING
            useAlm = True  # set to True to do harmonic space scaling, False for ud_grade
            NSIDE_big = 2048
            NSIDE_deg = 128
            while 4 * NSIDE_deg < lmax:
                NSIDE_deg *= 2
            print 'resampling maps at NSIDE = ', NSIDE_deg, '... '
            order_out = 'RING'
            if useAlm:
                # transform to harmonic space
                smicaMapRing = hp.reorder(smicaMap, n2r=True)
                maskMapRing = hp.reorder(maskMap, n2r=True)
                smicaCl, smicaAlm = hp.anafast(smicaMapRing,
                                               alm=True,
                                               lmax=lmax)
                maskCl, maskAlm = hp.anafast(maskMapRing, alm=True, lmax=lmax)
                # this gives 101 Cl values and 5151 Alm values.  Why not all 10201 Alm.s?

                # scale by pixel window functions
                bigWin = hp.pixwin(NSIDE_big)
                degWin = hp.pixwin(NSIDE_deg)
                winRatio = degWin / bigWin[:degWin.size]
                degSmicaAlm = hp.almxfl(smicaAlm, winRatio)
                degMaskAlm = hp.almxfl(maskAlm, winRatio)

                # re-transform back to real space
                smicaMapDeg = hp.alm2map(degSmicaAlm, NSIDE_deg)
                maskMapDeg = hp.alm2map(degMaskAlm, NSIDE_deg)

            else:
                smicaMapDeg = hp.ud_grade(smicaMap,
                                          nside_out=NSIDE_deg,
                                          order_in='NESTED',
                                          order_out=order_out)
                maskMapDeg = hp.ud_grade(maskMap,
                                         nside_out=NSIDE_deg,
                                         order_in='NESTED',
                                         order_out=order_out)
                # note: degraded resolution mask will no longer be only 0s and 1s.
                #   Should it be?  Yes.

            # turn smoothed mask back to 0s,1s mask
            threshold = 0.9
            maskMapDeg[np.where(maskMapDeg > threshold)] = 1
            maskMapDeg[np.where(maskMapDeg <= threshold)] = 0

            #testing
            #hp.mollview(smicaMapDeg)
            #plt.show()
            #hp.mollview(maskMapDeg)
            #plt.show()
            #return 0

            hp.write_map(mapDegFile, smicaMapDeg,
                         nest=False)  # use False if order_out='RING' above
            hp.write_map(maskDegFile, maskMapDeg, nest=False)

        else:  # just load previous degradations (dependent on previous lmax)
            print 'loading previously degraded map and mask...'
            smicaMapDeg = hp.read_map(mapDegFile, nest=False)
            maskMapDeg = hp.read_map(maskDegFile, nest=False)

        # find power spectra
        print 'find power spectra... '
        if useSPICE:
            ClFile1 = 'spiceCl_unmasked.fits'
            ClFile2 = 'spiceCl_masked.fits'

            # note: lmax for spice is 3*NSIDE-1 or less
            ispice(mapDegFile, ClFile1, subav="YES", subdipole="YES")
            Cl_unmasked = hp.read_cl(ClFile1)
            ispice(mapDegFile,
                   ClFile2,
                   maskfile1=maskDegFile,
                   subav="YES",
                   subdipole="YES")
            Cl_masked = hp.read_cl(ClFile2)
            Cl_mask = np.zeros(Cl_unmasked.shape[0])  # just a placeholder
            ell = np.arange(Cl_unmasked.shape[0])

        else:  # use anafast
            Cl_unmasked = hp.anafast(smicaMapDeg, lmax=lmax)
            Cl_masked = hp.anafast(smicaMapDeg * maskMapDeg, lmax=lmax)
            Cl_mask = hp.anafast(maskMapDeg, lmax=lmax)
            ell = np.arange(lmax + 1)  #anafast output seems to start at l=0

        # plot them
        doPlot = False  #True
        if doPlot:
            gcp.showCl(ell,
                       np.array([Cl_masked, Cl_unmasked]),
                       title='power spectra of unmasked, masked SMICA map')

        # Legendre transform to real space
        print 'Legendre transform to real space... '
        # note: getCovar uses linspace in x for thetaArray
        thetaDomain, CofTheta = getCovar(ell[:lmax + 1],
                                         Cl_unmasked[:lmax + 1],
                                         theta_i=theta_i,
                                         theta_f=theta_f,
                                         nSteps=nSteps,
                                         lmin=lmin)
        thetaDomain, CCutofThetaTA = getCovar(ell[:lmax + 1],
                                              Cl_masked[:lmax + 1],
                                              theta_i=theta_i,
                                              theta_f=theta_f,
                                              nSteps=nSteps,
                                              lmin=lmin)
        CofTheta *= 1e12  # K^2 to microK^2
        CCutofThetaTA *= 1e12  # K^2 to microK^2

        if useSPICE:
            CCutofTheta = CCutofThetaTA  #/(4*np.pi)
        else:
            thetaDomain, AofThetaInverse = getCovar(
                ell[:lmax + 1],
                Cl_mask[:lmax + 1],
                theta_i=theta_i,
                theta_f=theta_f,
                nSteps=nSteps,
                lmin=0)  # don't zilch the mask
            # note: zilching the mask's low power drastically changed C(theta) for masked anafast
            #   Not sure why.
            CCutofTheta = CCutofThetaTA / AofThetaInverse

        xArray = np.cos(thetaDomain * np.pi / 180.)

        # back to frequency space for S_{1/2} = CIC calculation
        if useSPICE:
            CCutofL = Cl_masked[:lmax + 1] * 1e12  #K^2 to microK^2
        else:
            legCoefs = legfit(xArray, CCutofTheta, lmax)
            CCutofL = legCoefs * (4 * np.pi) / (2 * ell[:lmax + 1] + 1)

        # S_{1/2}
        myJmn = getJmn(lmax=lmax)
        SMasked = np.dot(CCutofL[lmin:],
                         np.dot(myJmn[lmin:, lmin:], CCutofL[lmin:]))
        SNoMask = np.dot(
            Cl_unmasked[lmin:lmax + 1],
            np.dot(myJmn[lmin:, lmin:],
                   Cl_unmasked[lmin:lmax +
                               1])) * 1e24  #two factors of K^2 to muK^2

        # save results
        if useSPICE:
            np.save(
                saveFile2,
                np.array(
                    [thetaDomain, CofTheta, CCutofTheta, SNoMask, SMasked]))
        else:
            np.save(
                saveFile,
                np.array(
                    [thetaDomain, CofTheta, CCutofTheta, SNoMask, SMasked]))

    else:  # load from file
        if useSPICE:
            fileData = np.load(saveFile2)
        else:
            fileData = np.load(saveFile)
        thetaDomain = fileData[0]
        CofTheta = fileData[1]
        CCutofTheta = fileData[2]
        SNoMask = fileData[3]
        SMasked = fileData[4]

    return thetaDomain, CofTheta, CCutofTheta, SNoMask, SMasked
Ejemplo n.º 58
0
            # ok so this is a bit overcomplicated because we need to take into account CAR and HEALPIX
            # for CAR the pixel window function deconvolution is done in Fourier space and take into account
            # the anisotropy if the pixwin
            # In HEALPIX it's a simple 1d function in multipole space
            # we also need to take account the case where we have projected Planck into a CAR pixellisation since
            # the native pixel window function of Planck need to be deconvolved
            if win_T.pixel == "CAR":
                wy, wx = enmap.calc_window(win_T.data.shape)
                inv_pixwin_lxly = (wy[:, None] * wx[None, :])**(-1)
                pixwin_l[sv] = np.ones(2 * lmax)
                if sv == "Planck":
                    print("Deconvolve Planck pixel window function")
                    # we include this special case for Planck projected in CAR taking into account the Planck native pixellisation
                    # we should check if the projection doesn't include an extra pixel window
                    inv_pixwin_lxly = None
                    pixwin_l[sv] = hp.pixwin(2048)

            elif win_T.pixel == "HEALPIX":
                pixwin_l[sv] = hp.pixwin(win_T.nside)

        else:
            inv_pixwin_lxly = None

        t = time.time()
        for k, map in enumerate(maps):

            if win_T.pixel == "CAR":

                split = so_map.read_map(map, geometry=win_T.data.geometry)

                if d["src_free_maps_%s" % sv] == True:
Ejemplo n.º 59
0
#det_eff=.85
#ndays=15.*24*3600
#FPU=np.array([5,5,3])
#
#noise_const_array=ukdet*np.sqrt(4125.*60**2)/np.sqrt(FPU*ndet*det_eff*ndays)/pix_area_array*1e-6

#gamma_dust=6.626e-34/(1.38e-23*21)
#dust_factor=krj_to_kcmb*np.array([1e-6*(np.exp(gamma_dust*353e9)-1)/(np.exp(gamma_dust*x*1e9)-1)* (x/353.)**2.54 for x in bands])
#krj_to_kcmb=np.array([1.,1.,1.])
krj_to_kcmb=np.ones_like(bands)
#
sync_factor=krj_to_kcmb*np.array([1e-6*(30./x)**2 for x in bands])

beam=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)

bls=(hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)*hp.pixwin(nside_out)[:3*nside_out])**2


l=np.arange(3*nside_out)
ll=l*(l+1)/(2*np.pi)


def likelihood(cross,dcross,theory,name,title):

	Sig=np.sum(cross/(dcross**2))/np.sum(1./dcross**2)
	#Noise=np.std(np.sum(cross_array/dcross**2,axis=1)/np.sum(1./dcross**2))	\
	Noise=np.sqrt(1./np.sum(1./dcross**2))
	Sig1=np.sum(cross*(theory/dcross)**2)/np.sum((theory/dcross)**2)
	Noise1=np.sqrt(np.sum(dcross**2*(theory/dcross)**2)/np.sum((theory/dcross)**2))
	SNR=Sig/Noise
	SNR1=Sig1/Noise1
Ejemplo n.º 60
0
def covth(nside,ipok,lmax,bl,spectra,polar=True,temp=True,allinone=True):
    all=['I','Q','U']
    if  not temp:
        all=['Q','U']
    if not polar:
        all=['I']
    rpix=np.array(hp.pix2vec(nside,ipok))
    allcosang=np.dot(np.transpose(rpix),rpix)
    pixwin=hp.pixwin(nside)[0:lmax+1]
    nspec,nell=np.shape(spectra)
    ell=spectra[0]
    maskl=ell<(lmax+1)
    ell=ell[maskl]
    ctt=spectra[1][maskl]
    cee=spectra[2][maskl]
    cbb=spectra[3][maskl]
    cte=spectra[4][maskl]
    if nspec==5:
        print('Assuming EB and TB are zero')
        ceb=0
        ctb=0
    else:
        ceb=spectra[5][maskl]
        ctb=spectra[6][maskl]
    norm=(2*ell+1)/(4*np.pi)*(pixwin**2)*(bl[maskl]**2)
    effctt=norm*ctt
    effcte=norm*cte
    effcee=norm*cee
    effcbb=norm*cbb
    effceb=norm*ceb
    effctb=norm*ctb
    nbpixok=ipok.size
    nstokes=np.size(all)
    print(nstokes)
    cov=np.zeros((nstokes,nstokes,nbpixok,nbpixok))
    for i in np.arange(nbpixok):
        pyquad.progress_bar(i,nbpixok)
        for j in np.arange(i,nbpixok):
            if nstokes==1:
                pl=pl0(allcosang[i,j],lmax)
                TT=effctt*pl
                cov[0,0,i,j]=np.sum(TT)
                cov[0,0,j,i]=cov[0,0,i,j]
            if nstokes==2:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                cov[0,0,i,j] = np.sum( cji*cQQpsQU + sji*cQUpsUU )
                cov[0,0,j,i] = cov[0,0,i,j]
                cov[0,1,i,j] = np.sum(-sji*cQQpsQU + cji*cQUpsUU )
                cov[1,0,j,i] = cov[0,1,i,j]
                cov[1,1,i,j] = np.sum(-sji*cQUmsQQ + cji*cUUmsQU )
                cov[1,1,j,i] = cov[1,1,i,j]
                cov[0,1,j,i] = np.sum( cji*cQUmsQQ + sji*cUUmsQU )
                cov[1,0,i,j] = cov[0,1,j,i]
            if nstokes==3:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                pl=pl0(allcosang[i,j],lmax)
                f10=F1l0(allcosang[i,j],lmax)
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                TT=effctt*pl
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                TQ=-f10*effcte
                TU=-f10*effctb
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                cov[0,0,i,j] = np.sum( TT )
                cov[0,0,j,i] = cov[0,0,i,j]                
                cov[0,1,i,j] = np.sum( cji*TQ + sji*TU )
                cov[1,0,j,i] = cov[0,1,i,j]
                cov[1,0,i,j] = np.sum( cij*TQ + sij*TU )
                cov[0,1,j,i] = cov[1,0,i,j]
                cov[0,2,i,j] = np.sum(-sji*TQ + cij*TU )
                cov[2,0,j,i] = cov[0,2,i,j]
                cov[2,0,i,j] = np.sum(-sij*TQ + cij*TU )
                cov[0,2,j,i] = cov[2,0,i,j]
                cov[1,1,i,j] = np.sum( cji*cQQpsQU + sji*cQUpsUU )
                cov[1,1,j,i] = cov[1,1,i,j]
                cov[1,2,i,j] = np.sum(-sji*cQQpsQU + cji*cQUpsUU )
                cov[2,1,j,i] = cov[1,2,i,j]
                cov[2,1,i,j] = np.sum( cji*cQUmsQQ + sji*cUUmsQU )
                cov[1,2,j,i] = cov[2,1,i,j]
                cov[2,2,i,j] = np.sum(-sji*cQUmsQQ + cji*cUUmsQU )
                cov[2,2,j,i] = cov[2,2,i,j]
    if allinone==True:
        return(allmat2bigmat(cov))
    else:
        return cov