예제 #1
0
    def setUp(self):
        self.nside = 64
        self.lmax  = self.nside
        
        seed = 12345
        np.random.seed(seed)
        self.mapr = hp.synfast( np.ones(self.lmax+1), self.nside, pixwin=False, fwhm=0.0, sigma=None )
        self.mapi = hp.synfast( np.ones(self.lmax+1), self.nside, pixwin=False, fwhm=0.0, sigma=None )

        self.almg = hp.synalm( np.ones(self.lmax+1), self.lmax )
        self.almc = hp.synalm( np.ones(self.lmax+1), self.lmax )
def create_gaussian_alm():
    ng_data.load_cl()
    map_gaussian,alm_g = hp.synfast(ng_data.cl,nside=ng_config.nside,lmax=ng_config.lmax,alm=True)
    #print alm_g
    hp.fitsfunc.write_alm(ng_config.get_filename_alm_g(),alm_g) #save it
    print 'Map written: ' + ng_config.get_filename_alm_g()
    return alm_g
예제 #3
0
 def setUp(self):
     self.path = os.path.dirname( os.path.realpath( __file__ ) )
     try:
         self.map1 = [hp.ma(m) for m in hp.read_map(os.path.join(self.path, 'data', 'wmap_band_iqumap_r9_7yr_W_v4.fits'), (0,1,2))]
         self.map2 = [hp.ma(m) for m in hp.read_map(os.path.join(self.path, 'data', 'wmap_band_iqumap_r9_7yr_V_v4.fits'), (0,1,2))]
         self.mask = hp.read_map(os.path.join(self.path, 'data', 'wmap_temperature_analysis_mask_r9_7yr_v4.fits')).astype(np.bool)
     except exceptions.IOError:
         warnings.warn("""Missing Wmap test maps from the data folder, please download them from Lambda and copy them in the test/data folder:
         http://lambda.gsfc.nasa.gov/data/map/dr4/skymaps/7yr/raw/wmap_band_iqumap_r9_7yr_W_v4.fits
         http://lambda.gsfc.nasa.gov/data/map/dr4/skymaps/7yr/raw/wmap_band_iqumap_r9_7yr_V_v4.fits
         http://lambda.gsfc.nasa.gov/data/map/dr4/ancillary/masks/wmap_temperature_analysis_mask_r9_7yr_v4.fits
         on Mac or Linux you can run the bash script get_wmap_maps.sh from the same folder
         """)
     for m in chain(self.map1, self.map2):
         m.mask = np.logical_not(self.mask)
     self.cla = hp.read_cl(os.path.join(self.path, 'data', 'cl_wmap_fortran.fits'))
     cls = pyfits.open(os.path.join(self.path, 'data',
                                    'cl_iqu_wmap_fortran.fits'))[1].data
     # order of HEALPIX is TB, EB while in healpy is EB, TB
     self.cliqu = [cls.field(i) for i in (0,1,2,3,5,4)]
     nside = 32
     lmax = 64
     fwhm_deg = 7.
     seed = 12345
     np.random.seed(seed)
     self.mapiqu = hp.synfast(self.cliqu, nside, lmax=lmax, pixwin=False,
                              fwhm=np.radians(fwhm_deg), new=False)
예제 #4
0
    def synfast(self):
        """Function for the calculation of lensed CMB maps directly from
        lensed Cls using healpix's synfast routine.
        """
        # get the spectra. These are in CAMB format, we discard the last
        # three corresponding to dd, dt, de, respectively.
        ell, tt, ee, bb, te, _, _, _ = self.CMB_Specs
        lmax_cl = len(ell) + 1
        ell = np.arange(lmax_cl + 1)

        # in CAMB format so we must divide by the scaling factor
        factor = ell * (ell + 1.) / 2. / np.pi

        cl_teb = np.zeros((6, lmax_cl + 1))
        cl_teb[0, 2:] = tt / factor[2:]
        cl_teb[1, 2:] = ee / factor[2:]
        cl_teb[2, 2:] = bb / factor[2:]
        cl_teb[3, 2:] = te / factor[2:]
        cl_teb[4, 2:] = 0.
        cl_teb[5, 2:] = 0.

        np.random.seed(self.CMB_Seed)
        T, Q, U = hp.synfast(cl_teb, self.Nside, pol=True, new=True, verbose=False)

        @FloatOrArray
        def model(nu, **kwargs):
            cmb_map = np.array([T, Q, U]) * convert_units("uK_CMB", "uK_RJ", nu)
            if self.pixel_indices is None:
                return cmb_map
            else:
                return cmb_map[:, self.pixel_indices]

        return model
예제 #5
0
 def setUp(self):
     self.lmax = 64
     self.path = os.path.dirname( os.path.realpath( __file__ ) )
     self.map1 = [hp.ma(m) for m in hp.read_map(os.path.join(self.path, 'data', 'wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits'), (0,1,2))]
     self.map2 = [hp.ma(m) for m in hp.read_map(os.path.join(self.path, 'data', 'wmap_band_iqumap_r9_7yr_V_v4_udgraded32.fits'), (0,1,2))]
     self.mask = hp.read_map(os.path.join(self.path, 'data', 'wmap_temperature_analysis_mask_r9_7yr_v4_udgraded32.fits')).astype(np.bool)
     for m in chain(self.map1, self.map2):
         m.mask = np.logical_not(self.mask)
     self.cla = hp.read_cl(os.path.join(self.path, 'data', 'cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter.fits'))
     self.cl_fortran_nomask = hp.read_cl(os.path.join(self.path, 'data', 'cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter_nomask.fits'))
     cls_file = pyfits.open(os.path.join(self.path, 'data',
                                    'cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_IQU_lmax64_rmmono_3iter.fits'))
     # fix for pyfits to read the file with duplicate column names
     for i in range(2, 6):
         cls_file[1].header['TTYPE%d' % i] += '-%d' % i
     cls = cls_file[1].data
     # order of HEALPIX is TB, EB while in healpy is EB, TB
     self.cliqu = [np.array(cls.field(i)) for i in (0,1,2,3,5,4)]
     nside = 32
     lmax = 64
     fwhm_deg = 7.
     seed = 12345
     np.random.seed(seed)
     self.mapiqu = hp.synfast(self.cliqu, nside, lmax=lmax, pixwin=False,
                              fwhm=np.radians(fwhm_deg), new=False)
예제 #6
0
def main(nsim=0):

    nl = h._nl

    # Load map, mask, mll
    print ""
    print "Loading map, mask, mll, and calculating mll_inv..."

    map_data = hp.read_map(h._fn_map)
    mask = hp.read_map(h._fn_mask)
    mll = np.load(h._fn_mll)
    mll_inv = np.linalg.inv(mll)

    # Read in Planck map: normalize, remove mono-/dipole, mask
    print "Normalizing, removing mono-/dipole, and masking map..."
    map_masked = map_data * mask
    # Create cltt (cltt_data_masked) and correct it (cltt_data_corrected)
    print "Calculating cltt_data_masked, cltt_data_corrected..."
    cltt_data_masked = hp.anafast(map_masked)
    cltt_data_masked = cltt_data_masked[:nl]
    cltt_data_corrected = np.dot(mll_inv, cltt_data_masked)
    # Create simulation of map (map_sim) from cltt_data_corrected
    print "Creating and saving map_sim_%i..." % nsim
    map_sim = hp.synfast(cltt_data_corrected, h._nside)
    hp.write_map('output/map_sim_%i.fits' % nsim, map_sim)
예제 #7
0
파일: cls.py 프로젝트: carronj/MLlens
 def simulate_GaussianSky(self, NSIDE,seed = None):
     """
     Returns a healpy sky map from the Cl with synfast
     """
     if self.lmin > 0:
         if self.verbose: utils.PrtMsg("Filling ell (0 : " + str(self.lmin) + ") with zeros.", self.verbose)
         Cl = Cl_lmax(self.ell(), self.Cl).Cl  # In order to fill in the missing ells
     else:
         Cl = self.Cl
     if seed is not None : np.random.set_state(seed)
     return hp.synfast(Cl, NSIDE, new=True)
예제 #8
0
 def test_synfast(self):
     nside = 32
     lmax = 64
     fwhm_deg = 7.
     seed = 12345
     np.random.seed(seed)
     map_pregen = hp.read_map(os.path.join(self.path, 'data',
                                           'map_pregen_seed%d.fits' % seed))
     sim_map = hp.synfast(self.cla, nside, lmax = lmax, pixwin=False,
                          fwhm=np.radians(fwhm_deg), new=False, pol=False)
     np.testing.assert_array_almost_equal(sim_map, map_pregen,
                                          decimal=8)
예제 #9
0
파일: vksz.py 프로젝트: amanzotti/vksz
def toy_test_real_vs_harmonic(amp=100., nside=2**5, nexp=1000):

    # generate the signal map
    npix = hp.nside2npix(nside)
    signal = np.zeros(npix)
    ind_hpix = hp.ang2pix(nside, 0., 0., nest=False)
    signal[ind_hpix] = 1.
    # get autospectrum of signal
    lmax_tmp = 4*nside-1
    cl_signal = hp.anafast(signal, lmax=lmax_tmp)
    l = np.arange(len(cl_signal))

    # create white CL's with unit variance
    nl = np.ones_like(l, dtype=np.float)
    nl /= (np.sum(nl*(2.*l+1.))/4./np.pi)
    # create harmonic space weights.  the factor of 
    # 2L+1 is because we'll be dealing with 1d spectra rather than 2d.
    weight = (2.*l+1.)/nl

    est_real = []
    est_harm = []
    for i in range(nexp):
        print '%i/%i'%(i,nexp)
        # make noise map
        noise = hp.synfast(nl, nside)
        data = amp*signal + noise
        # get real space estimate of signal amplitude
        est_real.append(data[ind_hpix])
        # get harmonic space estimate of signal amplitude
        amp_tmp = np.sum(hp.anafast(signal, map2=data, lmax=lmax_tmp)*weight) / np.sum(cl_signal*weight)
        est_harm.append(amp_tmp)
    est_real = np.array(est_real)
    est_harm = np.array(est_harm)

    print ' '
    print ' mean(est_real): %0.2f'%est_real.mean()
    print ' mean(est_harm): %0.2f'%est_harm.mean()
    print '  var(est_real): %0.2f'%est_real.var()
    print '  var(est_harm): %0.2f'%est_harm.var()
    print '  VarRatio:   %0.2f'%(est_harm.var()/est_real.var())
    print '  std(est_real): %0.2f'%est_real.std()
    print '  std(est_harm): %0.2f'%est_harm.std()
    print '  StdRatio:   %0.2f'%(est_harm.std()/est_real.std())
    print ' '

    nbins=15
    pl.clf()
    pl.hist(est_real,bins=nbins, alpha=0.5)
    pl.hist(est_harm,bins=nbins, alpha=0.5)
    pl.legend(['real space','harmonic space'])
    pl.title('AMP=%0.3f, NEXP=%i, VarRatio=%0.3f'%(amp, nexp, est_harm.var()/est_real.var()))
    ipdb.set_trace()
예제 #10
0
def mk_map_onescale(nside,lmin=0,alpha=-2.17,smooth=1.):
    """
    One power law model -> random field realization
    """
    lmax = 3*nside - 1
    ll = np.array(range(lmin,lmax,1))
    Cl = np.power(ll,alpha)
    Cl[0] = 0. #zero mean

    Q = hp.synfast(Cl,nside,lmax=lmax)
    Qsm = hp.smoothing(Q,fwhm=np.radians(smooth))

    return Qsm
예제 #11
0
    def getpolsky(self):

        nside = self.nside
        tmap = self.getsky()

        cl = np.arange(3.0*nside-1)**(-FullSkySynchrotron.beta)
        cl[0] = 0.0

        qamp = healpy.synfast(cl, nside)
        uamp = healpy.synfast(cl, nside)

        polfrac = (qamp**2 + uamp**2).mean()**0.5

        qamp = qamp / polfrac * 0.3
        uamp = uamp / polfrac * 0.3

        tqumap = np.zeros((tmap.shape[0], 3, tmap.shape[1]), dtype=tmap.dtype)

        tqumap[:, 0] = tmap
        tqumap[:, 1] = qamp * tmap
        tqumap[:, 2] = uamp * tmap

        return tqumap
예제 #12
0
    def get_kernel(self, nside,lmax):

        cltt=abl.get_cltt(2*lmax)

        map1=hp.synfast([cltt,cltt,  cltt ,cltt*0], nside,lmax=lmax, new=False, pixwin=False )
        hp.write_map(self.path_temp+'map1.fits', map1)



        spice.spice(self.path_temp+'map1.fits', nlmax=lmax, polarization=True, kernel=self.path_ker+'ker.fits', clfile=self.path_temp+'cldum.dat', apodizesigma=self.apodizesigma, thetamax=self.thetamax )
        
        self.ker=pyf.open(self.path_ker+'ker.fits')[0].data[0]
        os.system('rm '+self.path_temp+'map1.fits')
        os.system('rm '+self.path_temp+'cldum.dat')
예제 #13
0
 def test_map2alm(self):
     nside = 32
     lmax = 64
     fwhm_deg = 7.
     seed = 12345
     np.random.seed(seed)
     orig = hp.synfast(self.cla, nside, lmax=lmax, pixwin=False,
                       fwhm=np.radians(fwhm_deg), new=False)
     tmp = np.empty(orig.size * 2)
     tmp[::2] = orig
     maps = [orig, orig.astype(np.float32), tmp[::2]]
     for input in maps:
         alm = hp.map2alm(input, iter=10)
         output = hp.alm2map(alm, nside)
         np.testing.assert_allclose(input, output, atol=1e-4)
예제 #14
0
def test_rotate_map_polarization_with_spectrum():
    """Rotation of reference frame should not change the angular power spectrum.
    In this test we create a map from a spectrum with a pure EE signal and check
    that the spectrum of this map and the spectrum of the same map rotated
    from Galactic to Ecliptic agrees.
    This test checks if the QU rotation is correct"""
    nside = 32
    cl = np.zeros((6, 96), dtype=np.double)
    # Set ell=1 for EE to 1
    cl[1][2] = 1
    gal2ecl = Rotator(coord=["G", "E"])
    m_original = hp.synfast(cl, nside=nside, new=True)
    cl_from_m_original = hp.anafast(m_original)
    m_rotated = gal2ecl.rotate_map_pixel(m_original)
    cl_from_m_rotated = hp.anafast(m_rotated)

    assert np.abs(cl_from_m_rotated - cl_from_m_original).sum() < 1e-2
예제 #15
0
파일: cltools.py 프로젝트: jegudmunds/code
def genmap(dir_maps='data/',nside=512, lmax=700):
    """
    Reads in an input power spectrum and generates a set of I,Q,U maps
    using synfast
    """

    # Read model spectra
    ellm, cltmp = readmodel(lfac=False,bbzero=False)
    cltmp = cltmp[:4]
    clm = cltmp.copy()

    #clm[1] = cltmp[3]  # TE
    #clm[2] = cltmp[1]  # EE
    #clm[3] = cltmp[2]  # BB
    (syt,syq,syu) = hp.synfast(clm, nside, pixwin=True, lmax=lmax, 
      new=True)
    hp.write_map(dir_maps+"map_input.fits", [syt,syq,syu])
    return syt, syq, syu
예제 #16
0
 def test_synfast(self):
     nside = 32
     lmax = 64
     fwhm_deg = 7.0
     seed = 12345
     np.random.seed(seed)
     map_pregen = hp.read_map(
         os.path.join(self.path, "data", "map_synfast_seed%d.fits" % seed), (0, 1, 2)
     )
     sim_map = hp.synfast(
         self.cliqu,
         nside,
         lmax=lmax,
         pixwin=False,
         fwhm=np.radians(fwhm_deg),
         new=False,
         pol=True,
     )
     np.testing.assert_array_almost_equal(sim_map, map_pregen, decimal=8)
예제 #17
0
 def test_map2alm(self):
     nside = 32
     lmax = 64
     fwhm_deg = 7.
     seed = 12345
     np.random.seed(seed)
     orig = hp.synfast(self.cla,
                       nside,
                       lmax=lmax,
                       pixwin=False,
                       fwhm=np.radians(fwhm_deg),
                       new=False)
     tmp = np.empty(orig.size * 2)
     tmp[::2] = orig
     maps = [orig, orig.astype(np.float32), tmp[::2]]
     for input in maps:
         alm = hp.map2alm(input, iter=10)
         output = hp.alm2map(alm, nside)
         np.testing.assert_allclose(input, output, atol=1e-4)
예제 #18
0
def get_cmb_sim_hp(signal, nside_out):
    """Generate a healpix realization of the spectra.

    Parameters
    ----------
    signal: dictionary
        dictionary containing spectra starting from ell = 0 with keys
        TT, EE, BB, TE.
    nside_out: int
        output map resolution
    """
    cmb_sim = hp.synfast(
        cls=(signal["TT"], signal["EE"], signal["BB"], signal["TE"]),
        nside=nside_out,
        pixwin=True,
        verbose=False,
        new=True,
    )
    return cmb_sim
예제 #19
0
 def test_synfast(self):
     nside = 32
     lmax = 64
     fwhm_deg = 7.0
     seed = 12345
     np.random.seed(seed)
     map_pregen = hp.read_map(
         os.path.join(self.path, "data", "map_synfast_seed%d.fits" % seed),
         (0, 1, 2))
     sim_map = hp.synfast(
         self.cliqu,
         nside,
         lmax=lmax,
         pixwin=False,
         fwhm=np.radians(fwhm_deg),
         new=False,
         pol=True,
     )
     np.testing.assert_array_almost_equal(sim_map, map_pregen, decimal=8)
예제 #20
0
    def get_cov(self, nside,lmax,N, cl):
        self.cov=nm.zeros((lmax+1, lmax+1))
        cov=self.cov.copy()

     
        for i in range(N):
            ####### simulate maps

            map1=hp.synfast(cl, nside, lmax=nside, new=False, pixwin=False )
            hp.write_map(self.path_maps+'sim_%d.fits'%i,map1)


            ##### spice the maps

        
            spice.spice(self.path_maps+'sim_%d.fits'%i, nlmax=lmax+400, clfile=self.path_cls+'cl_spice_sim_%d.dat'%i, maskfile=self.maskf, apodizesigma=self.apodizesigma, thetamax=self.thetamax)

            ######### Erase the map

            os.system('rm %s'%self.path_maps+'sim_%d.fits'%i)

        ## load the cls
        tab=nm.zeros((N, lmax+1))

        for i in range(N):
            tab[i,:]=nm.loadtxt(self.path_cls+'cl_spice_sim_%d.dat'%i)[0:lmax+1,1]

        self.tab=tab
        ## compute the cov
        self.meancl=nm.mean(tab, axis=0)
        for i in range(N):
            cov+=nm.dot(nm.matrix(tab[i,:]).T, nm.matrix(tab[i,:]))

        cov/=N
        cov-=nm.dot(nm.matrix(self.meancl).T, nm.matrix(self.meancl))
        ##cov cl, clp = E ( cl* clp) - E[cl] E[clp]
        self.cov=cov
        nm.savetxt(self.path_ker+'cov.dat', cov)
        l=nm.arange(lmax+1)
        
        cov_th=2./(2*l+1)/nm.mean(self.mask) *( cl[0:lmax+1]**2   )
        nm.savetxt(self.path_ker+'cov_th.dat', cov_th)
예제 #21
0
    def compute_cmb(self):
        """ Function to calculate a set of CMB Q and U maps from a given
        cosmology and instrument parameters. We generate a CMB realization
        from a run of CLASS for the given cosmology. This is then scaled
        to a the requested set of frequencies specified in the instrument
        configuration.
        """
        try:
            assert not self.nmc % 2
        except AssertionError:
            print('Odd number of MC simulations, can not compute pairs of '
                  'cross-spectra. Exiting.')
            raise

        nus = np.array(self.instrument['nus'])
        nfreqs = len(nus)
        fwhm = self.instrument['beam_fwhm']
        # claculate the power spectrum for this cosmology
        cmb_cls = self.compute_theory_cls()
        # set the random seed and iterate over the number of mc realizations
        # of the CMB requested. for now this will always be one, but may be
        # changed in the future.
        np.random.seed(None)
        # define array containing CMB. This is of shape (Nmc, Nfreq, Npol, Npix)
        # The same realization is placed at imc, and Nmc - imc - 1, as
        # we will use these maps to calculate cross spectra later.
        cmb = np.empty((self.nmc, nfreqs, 3, self.npix))
        print("Generating CMB realizations")
        for imc in tqdm(range(int(self.nmc / 2))):
            print("Computing CMB map ", imc, " of ", self.nmc / 2)
            cmb_real = np.array(
                hp.synfast(cmb_cls,
                           self.nside,
                           new=True,
                           pol=True,
                           verbose=False,
                           fwhm=np.pi / 180. * fwhm / 60.))
            cmb_real_ukrj = kcmb2rj(nus)[..., None, None] * cmb_real
            cmb[imc, :, :, :] = cmb_real_ukrj
            cmb[self.nmc - imc - 1, :, :, :] = cmb_real_ukrj
        # scale the CMB map from the CMB units to uK_RJ.
        return cmb
예제 #22
0
def test_single(cl, mask, rseed, lmin=0, lmax=100, nside=256):
    print_message('Single test with my code')
    print_message('Mask coverage = %f' % (np.average(mask)))
    #mask = np.logical_not(hp.ud_grade(mask, nside_out = nside))
    mask = hp.ud_grade(mask, nside_out=nside)
    print_message('Mask coverage for nside %d = %f' %
                  (nside, np.average(mask)))

    np.random.seed(rseed)
    st = time.time()
    m = hp.synfast(cl, nside=nside, new=True)
    print_debug('Time for synfast:', time.time() - st)

    st = time.time()
    cl_ana = hp.anafast(m)
    print_debug('Time for get anafast:', time.time() - st)

    st = time.time()
    lmins = np.arange(lmin, lmax)
    lmaxs = lmins + 1
    bins = xpol.Bins(lmins, lmaxs)
    xp = xpol.Xpol(mask, bins)
    print_debug('Time for initalizing x-pol:', time.time() - st)

    st = time.time()
    biased, unbiased_tmp = xp.get_spectra(m)
    print_debug('Time for get spectra from x-pol:', time.time() - st)

    unbiased = np.zeros(biased.shape)
    unbiased[:, 2:] = unbiased_tmp

    plt.figure()
    plt.loglog(np.abs(cl2dl(cl[:3].T)))
    plt.loglog(np.abs(cl2dl(cl_ana[:3].T)), '*-', lw=0.5)
    plt.loglog(np.abs(cl2dl(biased[:3].T)), 'x-', lw=0.5)
    plt.loglog(np.abs(cl2dl(unbiased[:3])).T, '+-', lw=0.5)
    plt.ylim(1e-6, 1e4)
    plt.xlabel = 'multipole moment ($l$)'
    plt.ylabel = '$D_l (K^2)'
    plt.title("x-pol")

    return biased, unbiased
예제 #23
0
    def __init__(self, mask_file=None, f=None, maps=None, bl=None, fidcl=None):

        mask = ones(12 * 16**2) if mask_file is None else H.read_map(mask_file)

        self.fsky = mask.sum() / mask.size
        self.f = ones(30) if f is None else f

        qk = quickkern(200)
        imll = inv(qk.get_mll(H.anafast(mask, lmax=60))[:49, :49])

        if maps is None:
            mp1 = mp2 = H.synfast(fidcl, 16, new=True, verbose=False)
            bl = ones(50)
        else:
            mp1, mp2 = (H.ud_grade(H.read_map(m), 16) * 1e6 for m in maps)

        self.clobs = dot(imll, H.anafast(mask * mp1, mask * mp2,
                                         lmax=48)) / bl[:49]**2
        self.chi2s = [
            stats.chi2((2 * l + 1) * self.fsky * self.f[l]) for l in range(30)
        ]
예제 #24
0
def getcov_est(dls, nside=4, pls=None, lmax=None, nsample=100, isDl=True):
    if (lmax==None):
        lmax = nside*3-1

    if (isDl):
        cls = dl2cl(dls)
    else:
        cls = dls.copy()

    ell = np.arange(lmax+1)

    maparr = []
    for i in range(nsample):
        np.random.seed(i)
        mapT = hp.synfast(cls, nside=nside, verbose=False)
        maparr.append(mapT)

    maparr = (np.array(maparr)).T
    cov = np.cov(maparr)

    return cov
예제 #25
0
def sim_whitenoise(nside,
                   lmax,
                   w,
                   theta,
                   ellkneeT=0,
                   alphaT=0,
                   ellkneeP=0,
                   alphaP=0,
                   lmin=2):
    nl, pTl, pPl, bl = whitenoise(lmax,
                                  w,
                                  theta,
                                  ellkneeT,
                                  alphaT,
                                  ellkneeP,
                                  alphaP,
                                  lmin=lmin)
    return hp.synfast(
        (nl / 2. * pTl * bl, nl * pPl * bl, nl * pPl * bl, np.zeros(lmax + 1)),
        nside,
        lmax=lmax,
        new=True)[:3]
예제 #26
0
def mk_map_SCK(nside,nu,A,beta,alpha,lmin=0,l_f=1000,nu_f=130,smooth=1.):
    """
    Santos Cooray and Knox (2005) diffuse foreground model -> random field realization

    #Fiducial parameters at l_f=1000, nu_f=130 MHz
    #
    # Src (i)                        A (mK^2)  beta  \bar{alpha}  xi
    #
    #Extragalactic point sources     57        1.1   2.07         1.0
    #Extragalactic bremstrahlung     0.014     1.0   2.10         35
    #Galactic synchrotron            700       2.4   2.80         4.0
    #Galactic bremstrahlung          0.088     3.0   2.15         35
    """
    lmax = 3*nside - 1
    ll = np.array(range(lmin,lmax,1))
    Cl = A*np.power(float(l_f)/ll,beta)*np.power(nu_f/nu,2*alpha)
    Cl[0] = 0. #zero mean

    Q = hp.synfast(Cl,nside,lmax=lmax)
    Qsm = hp.smoothing(Q,fwhm=np.radians(smooth))

    return Qsm
예제 #27
0
파일: common.py 프로젝트: damonge/QxK
def random_map(seed,mask,fname_cl,fname_out='none',use_wiener=False) :
    """Generates gaussian random field with correct power spectrum
    mask : healpix map containing a binary mask
    fname_cl : path to ascii file containing the field's power spectrum
    fname_out : path to output FITS file
    """
    np.random.seed(seed)
    nside=hp.npix2nside(len(mask))
    ll,nll,cll=np.loadtxt(fname_cl,unpack=True)
    cl=np.zeros(int(ll[-1]+1)); cl[int(ll[0]):]=cll
    nl=np.zeros(int(ll[-1]+1)); nl[int(ll[0]):]=nll
    if use_wiener :
        alm=hp.synalm(cl,lmax=2048,new=True,verbose=False) 
        alm=hp.almxfl(alm,(cl-nl)/np.maximum(cl,np.ones_like(cl)*1E-10))
        mp=hp.alm2map(alm,nside,lmax=2048)
    else :
        mp=hp.synfast(cl,nside,lmax=2048,new=True,verbose=False)
    mp*=mask

    if fname_out!='none' :
        hp.write_map(fname_out,mp)

    return mp
예제 #28
0
 def test_map2alm_lsq(self):
     nside = 32
     lmax = 64
     fwhm_deg = 7.0
     seed = 12345
     np.random.seed(seed)
     orig = hp.synfast(
         self.cla,
         nside,
         lmax=lmax,
         pixwin=False,
         fwhm=np.radians(fwhm_deg),
         new=False,
     )
     tmp = np.empty(orig.size * 2)
     tmp[::2] = orig
     maps = [orig, orig.astype(np.float32), tmp[::2]]
     for input in maps:
         alm, l2, it = hp.map2alm_lsq(input, tol=1e-4, lmax=lmax, mmax=lmax)
         np.testing.assert_equal(l2 < 1e-3, True)
         np.testing.assert_equal(it < 15, True)
         output = hp.alm2map(alm, nside)
         np.testing.assert_allclose(input, output, atol=1e-4)
예제 #29
0
def get_cmb(Nside, px_unseen):
    pars = camb.CAMBparams()
    #This function sets up CosmoMC-like settings, with one massive neutrino and helium set using BBN consistency
    pars.set_cosmology(H0=67.74, ombh2=0.0223, omch2=0.1188, omk=0, tau=0.066)
    # Tensors on
    pars.WantTensors = True
    pars.InitPower.set_params(ns=0.9667, r=0.5)
    # Power spectrum will be 3 * Nside - 1
    pars.set_for_lmax(3 * Nside - 1, lens_potential_accuracy=0)
    #calculate results for these parameters
    results = camb.get_results(pars)
    #get dictionary of CAMB power spectra
    cl_total = results.get_total_cls(3 * Nside - 1)
    # Needs to be re-arranged
    tmp = [cl_total[:, 0], cl_total[:, 1], cl_total[:, 2], cl_total[:, 3]]
    # This comes out as a list
    cmb_synfast = hp.synfast(tmp, Nside, new=True)
    # Rather cast it into a numpy array and change K->micro K!
    cmb_out = np.zeros((3, len(px_unseen)), dtype='float32')
    cmb_out[0] = cmb_synfast[0][px_unseen] * 1e6
    cmb_out[1] = cmb_synfast[1][px_unseen] * 1e6
    cmb_out[2] = cmb_synfast[2][px_unseen] * 1e6
    return cmb_out
예제 #30
0
def get_beta_map(nside, beta0, amp, gamma, l0=80, l_cutoff=2, seed=None):
    """
    Returns realization of the spectral index map.

    Args:
        nside: HEALPix resolution parameter.
        beta0: mean spectral index.
        amp: amplitude
        gamma: tilt
        l0: pivot scale (default: 80)
        l_cutoff: ell below which the power spectrum will be zero.
            (default: 2).
        seed: seed (if None, a random seed will be used).

    Returns:
        Spectral index map
    """
    if seed is not None:
        np.random.seed(seed)
    ls = np.arange(3*nside)
    cls = get_delta_beta_cl(amp, gamma, ls, l0, l_cutoff)
    mp = hp.synfast(cls, nside, verbose=False)
    mp += beta0
    return mp
예제 #31
0
def test_rotate_ellipticities():
    nside = 128
    npix = hp.nside2npix(nside)
    ls = np.arange(3 * nside)
    cl = 1 / (ls + 10)**2
    cl0 = np.zeros(3 * nside)
    _, q, u = hp.synfast([cl0, cl, cl0, cl0], nside, new=True)
    r = hp.Rotator(coord=['G', 'C'])
    qr, ur = r.rotate_map_pixel([q, u])
    ra, dec = hp.pix2ang(nside, np.arange(npix), lonlat=True)

    # The catalog now has positions and ellipticities
    # in Equatorial coordinates.
    cat = {'RA': ra, 'DEC': dec, 'e1': qr, 'e2': ur}

    r = hp.Rotator(coord=['C', 'G'])

    # Rotate back to Galactic coordinates and compare with
    # input maps. Differences are expected due to different
    # interpolation types used by healpy's `rotate_map_pixel`
    # and averaging by galaxy positions, so we compare against
    # half of a standard deviation of the input maps (even though
    # maps actually agree at the ~0.25*sigma level).
    ns = 32
    n1 = xc.mappers.get_map_from_points(cat, ns, rot=r)
    q1, u1 = xc.mappers.get_map_from_points(cat,
                                            ns,
                                            rot=r,
                                            qu=[cat['e1'], cat['e2']])
    q1 /= n1
    u1 /= n1
    q = hp.ud_grade(q, nside_out=ns)
    u = hp.ud_grade(u, nside_out=ns)
    std_comp = np.sqrt(np.mean(q**2 + u**2))
    assert np.all(np.fabs(q - q1) < 0.5 * std_comp)
    assert np.all(np.fabs(u - u1) < 0.5 * std_comp)
예제 #32
0
                           np.log10(hpm_cl[fitrange[0]:fitrange[1]]), 1))
except TypeError:
    print 'fitrange should be a tuple of two integer for min and max of \
    fitting range'

# Put together our extrapolated power spectrum
original_cl = np.concatenate((hpm_cl,
                             np.zeros(3 * nside_out - 1 - hpm_cl.size)))
extrap_cl = np.copy(original_cl)
extrap_cl[fitrange[1]:] =\
    10 ** (hpm_cl_fit(np.log10(np.arange(fitrange[1], extrap_cl.size))))
diff_cl = -1 * (original_cl - extrap_cl)
diff_cl[diff_cl < 0] = 0.  # else we have a problem

# Convert the different in power spectrum to a Gaussian random field
hpm_diff = hp.synfast(diff_cl, nside_out)

# Interpolate the input hpm map to higher NSide
# healpy has a ud_grade function to interpolate map to higher side, but it
# does not allow clipping of power spectrum before interpolation of the map.
hpm_original = hp.alm2map(hpm_alm, nside_out)

# Our diffuse model is the original hpm map interpolated to higher nside,
# plus the small structure map.
hpm_extrap = hpm_original + hpm_diff
hp.write_map(hpm_out_name, hpm_extrap, dtype=np.float64, fits_IDL=False,
             coord='G')
hpm_extrap_cl = hp.anafast(hpm_extrap)
plt.loglog(np.arange(hpm_extrap_cl.size), hpm_extrap_cl, 'y', label='Model')
plt.loglog(np.arange(hpm_cl.size), hpm_cl, 'b--', lable='Haslam')
plt.loglog(np.arange(diff_cl.size), diff_cl, 'r-.', lable='Small Structure')
예제 #33
0
if True:
    randmap=hp.read_map("../recon_semifake/rand_map.fits.gz",0)
    hp.write_map("rand_map.fits.gz",randmap)
    maskedrandmap=mask*(randmap+np.random.normal(scale=0.02,size=len(randmap)))
    hp.write_map("maskedrand_map.fits.gz",maskedrandmap)
if True:
#load galaxy map
    randmap=hp.read_map("2MPZ.gz_0.01_0.1_smoothed.fits.gz",0)
    randmap=hp.pixelfunc.ud_grade(randmap,nside_out = nside, order_in = 'RING', order_out = 'RING')
    meanrandmap=np.mean(randmap)
#    mask[randmap<1e-2*meanrandmap]=0
    maskedrandmap=mask*randmap
# GENERATE RANDOM MAP WITH THE SAME CLS AS LOADED
if False:
    cl = hp.anafast(randmap)
    randmap=hp.synfast(cl,nside)
    maskedrandmap=mask*randmap
    hp.write_map("rand_map.fits.gz",randmap)
    hp.write_map("maskedrand_map.fits.gz",maskedrandmap)

hp.mollview(mask,coord='C',rot = [0,0.3],
            title='Mask', unit='prob', xsize=1024)
hp.graticule()
plt.savefig("Mask.png")
# plt.show()
plt.close()

hp.mollview(randmap,coord='C',rot = [0,0.3],
            title='Random Map', unit='prob', xsize=1024, norm='hist')
hp.graticule()
plt.savefig("RandMap.png")
예제 #34
0
import healpy as hp
import numpy as np

# Add SPT noise, chi-by-eye to Henning SPT-500deg^2 paper N_l and
# functional form in  http://users.physics.harvard.edu/~buza/20161220_chkS4/

#sigmap = 9.0 # uK-arcmin, SPT
sigmap = 1.2  # uK-arcmin, CMB-S4

lknee = 250.
lexp = -1.8

l = np.arange(8000) * 1.0
Nl = 4 * np.pi / (41253. * 60**2) * (1 + (l / lknee)**(lexp)) * sigmap**2
Nl[0] = 0

# Get noise realization
Nside = 1024

for rlz in range(26, 100):

    print(rlz)

    hmapTn = hp.synfast(Nl, Nside, new=True, verbose=False)
    hmapQn = hp.synfast(Nl, Nside, new=True, verbose=False)
    hmapUn = hp.synfast(Nl, Nside, new=True, verbose=False)

    hp.write_map('input_maps/S4_noise_map_r{:04d}.fits'.format(rlz),
                 [hmapTn, hmapQn, hmapUn])
예제 #35
0
covlim=0.1


####### Create some sampling
center = equ2gal(racenter, deccenter)
sampling = create_sweeping_pointings(
    [racenter, deccenter], duration, ts, angspeed, delta_az, nsweeps_el,
    angspeed_psi, maxpsi)

####### Full instrument
instrument = QubicInstrument(filter_nu=150e9,
                    detector_nep=4.7e-17*np.sqrt(len(sampling) * sampling.period / (365 * 86400)))

### Input map
nside_in=64
mapi,mapq,mapu=hp.synfast(spectra[1:],nside_in,new=True)
input_maps=np.array([mapi,mapq,mapu]).T

### Prepare input / output data
nside = 64
scene = QubicScene(nside, kind='IQU')




from Quad import mapmake_jc_lib as mm
reload(mm)

tod_signal, tod_noise, tod = mm.get_tod(instrument, sampling, scene, input_maps, 
                                        withplanck = False, photon_noise=False)
예제 #36
0
    def setUp(self):
        fixture_name = os.path.splitext(os.path.basename(__file__))[0]
        self.outdir = create_outdir(self.comm, fixture_name)
        self.rank = 0
        if self.comm is not None:
            self.rank = self.comm.rank
        if self.rank == 0:
            for fname in glob.glob("{}/*".format(self.outdir)):
                try:
                    os.remove(fname)
                except OSError:
                    pass
        if self.comm is not None:
            self.comm.barrier()

        self.nobs = 1
        self.data = create_distdata(self.comm, obs_per_group=self.nobs)

        self.ndet = self.data.comm.group_size
        self.sigma = 1
        self.rate = 50.0
        self.net = self.sigma / np.sqrt(self.rate)
        self.alpha = 2
        self.fknee = 1e0

        # Create detectors
        (
            dnames,
            dquat,
            depsilon,
            drate,
            dnet,
            dfmin,
            dfknee,
            dalpha,
        ) = boresight_focalplane(
            self.ndet,
            samplerate=self.rate,
            fknee=self.fknee,
            alpha=self.alpha,
            net=self.net,
        )

        # Pixelization
        self.sim_nside = 32
        self.map_nside = 32
        self.pointingmode = "IQU"
        self.nnz = 3

        # Samples per observation
        self.npix = 12 * self.sim_nside**2
        self.ninterval = 4
        self.totsamp = self.ninterval * self.npix

        # Define intervals
        intervals = []
        interval_length = self.npix
        istart = 0
        while istart < self.totsamp:
            istop = istart + interval_length
            intervals.append(
                Interval(
                    start=istart / self.rate,
                    stop=istop / self.rate,
                    first=istart,
                    last=istop - 1,
                ))
            istart = istop

        # Construct an uncorrelated analytic noise model for the detectors

        noise = AnalyticNoise(
            rate=drate,
            fmin=dfmin,
            detectors=dnames,
            fknee=dfknee,
            alpha=dalpha,
            NET=dnet,
        )

        # Populate the observations

        for iobs in range(self.nobs):
            if iobs % 3 == 1:
                rot = qa.from_angles(np.pi / 2, 0, 0)
            if iobs % 3 == 2:
                rot = qa.from_angles(np.pi / 2, np.pi / 2, 0)
            else:
                rot = None

            tod = TODHpixSpiral(
                self.data.comm.comm_group,
                dquat,
                self.totsamp,
                detranks=self.data.comm.group_size,
                rate=self.rate,
                nside=self.sim_nside,
                rot=rot,
            )

            self.data.obs[iobs]["tod"] = tod
            self.data.obs[iobs]["noise"] = noise
            self.data.obs[iobs]["intervals"] = intervals

        # Write processing masks

        self.npix = 12 * self.map_nside**2
        pix = np.arange(self.npix)
        pix = hp.reorder(pix, r2n=True)

        self.binary_mask = np.logical_or(pix < self.npix * 0.45,
                                         pix > self.npix * 0.55)
        self.maskfile_binary = os.path.join(self.outdir, "binary_mask.fits")
        hp.write_map(
            self.maskfile_binary,
            self.binary_mask,
            dtype=np.float32,
            overwrite=True,
            nest=True,
        )

        self.smooth_mask = (np.abs(pix - self.npix / 2) / (self.npix / 2))**0.5
        self.maskfile_smooth = os.path.join(self.outdir, "apodized_mask.fits")
        hp.write_map(
            self.maskfile_smooth,
            self.smooth_mask,
            dtype=np.float32,
            overwrite=True,
            nest=True,
        )

        # Synthesize an input map
        self.lmax = 2 * self.sim_nside
        self.cl = np.ones([4, self.lmax + 1])
        self.cl[:, 0:2] = 0
        fwhm = np.radians(10)
        self.inmap = hp.synfast(
            self.cl,
            self.sim_nside,
            lmax=self.lmax,
            mmax=self.lmax,
            pol=True,
            pixwin=True,
            fwhm=np.radians(30),
            verbose=False,
        )
        self.inmap = hp.reorder(self.inmap, r2n=True)
        self.inmapfile = os.path.join(self.outdir, "input_map.fits")
        hp.write_map(self.inmapfile, self.inmap, overwrite=True, nest=True)

        return
예제 #37
0
colombi1_cmap.set_bad("gray")  # color of missing pixels
colombi1_cmap.set_under(
    "white")  # color of background, necessary if you want to use
# this colormap directly with hp.mollview(m, cmap=colombi1_cmap)
cmap_planck = colombi1_cmap

import matplotlib
matplotlib.use("Agg")
Nside = 512

cl = hp.fitsfunc.read_cl("cl.fits")

gauss_map = hp.synfast(cl[0],
                       512,
                       lmax=3 * Nside - 1,
                       fwhm=0,
                       pixwin=True,
                       verbose=False,
                       pol=False)

dpi = 800
fig_size_inch = 6, 4.5
fig = plt.figure(1, figsize=(6, 4.5))

hp.mollview(gauss_map,
            fig=fig.number,
            xsize=2000,
            nest=False,
            title='',
            cmap=cmap_planck,
            cbar=False)
예제 #38
0
import healpy as hp

nside=256
ell=np.arange(3*nside)

sig=0.1
l_low=5
l_mid=20
l_high=60
cl_low=exp(-(ell-l_low)**2/(2*sig**2))
cl_mid=exp(-(ell-l_mid)**2/(2*sig**2))
cl_high=exp(-(ell-l_high)**2/(2*sig**2))
map_low=hp.synfast(cl_low,nside)
map_mid=hp.synfast(cl_mid,nside)
map_high=hp.synfast(cl_high,nside)

hp.mollview(map_low)
hp.mollview(map_mid)
hp.mollview(map_high)

figure()
plot(ell,cl_low,lw=3)
xlim(0,100)
ylim(0,1.2)
xlabel('$\ell$',fontsize=20)
ylabel('$C_\ell$',fontsize=20)

figure()
plot(ell,cl_mid,lw=3)
xlim(0,100)
ylim(0,1.2)
예제 #39
0
    jds = np.load(opts.jd)['jd']
    jds = jds[40:50]
    # range of frequencies
    frequency = np.linspace(opts.start, opts.stop, opts.chan)
    np.savez(open('frequency.npz', 'wb'), frequency=frequency)

    if opts.healpix:
        ra, dec = convHealCoord(opts.nside)
        if opts.pol:
            if opts.pmap == None:
                # generates realizations of polarized map from angular power spectrum
                random.seed(1001)
                ll = np.arange(1, 2700)
                A_700 = 0.64  #0.05 # RM normalization factor
                P_cl = A_700 * ((ll / 700.)**(-1.65))  # angular power spectrum
                _dat = hp.synfast(P_cl,
                                  nside)  # generating healpix realization
                polmap = _dat.copy()
                pfrac = None
                RM = None
            else:
                polmap = hp.read_map(opts.pmap)
                polmap = hp.ud_grade(polmap, opts.nside)
        else:
            data = hp.read_map(args[0])
            data = hp.ud_grade(data, opts.nside)
            pfrac = 0.1
            RM = 12
            alpha = -2.6
            polmap = None
    else:
        data, ra, dec, alpha, RM, pfrac = loadCat(args[0])
예제 #40
0
xlim(0,600)
ylim(0.01,100)
xlabel('$\ell$')
ylabel('$\sqrt{\ell(\ell+1)C_\ell/(2\pi)}$'+'    '+'$[\mu K]$ ')
legend(loc='lower right',frameon=False)



nside=64
lmax=3*nside
ell=spectra[0]
maskl=ell<(lmax+1)
bl=np.ones(maskl.size)

fwhmrad=0.5*np.pi/180
mapi,mapq,mapu=hp.synfast(spectra[1:],nside,fwhm=fwhmrad,pixwin=True,new=True)
hp.mollview(mapi)
hp.mollview(mapq)
hp.mollview(mapu)
maps=[mapi,mapq,mapu]


############## T only
#ds_dcb=0
#nbpixok=1000
#mask=(np.arange(12*nside**2) >= nbpixok)
#maskok=~mask
#ip=np.arange(12*nside**2)
#ipok=ip[~mask]

#mapi,mapq,mapu=hp.synfast(spectra[1:],nside,fwhm=fwhmrad,pixwin=True,new=True)
예제 #41
0
from astropy.io import fits
import matplotlib.pyplot as plt
import cltools as ct
import matplotlib.cm as cm
import claw
from numpy import *

n=500000
Nside=64
Npix=12*Nside**2
Cls_in_bin=12
lmax=(3*Nside)-1

#mapa=ct.randmap(n,Nside)
clth=np.loadtxt('theory_fit.txt')
mapa=hp.synfast(clth[:,1][0:lmax+1],Nside)


plt.figure()
plt.plot(clth[:,0],clth[:,1], label=' Power spectrum icecube\n podatkov brez shot noise')
plt.xlim(0,lmax)
plt.xlabel('$\ell$')
plt.ylabel('$C_\ell$')
plt.show()

print ("max,min,mean=",mapa.max(), mapa.min(),mapa.mean())
b=cm.BuPu                                                          #      
b.set_under("w")                                                        #
hp.mollview(mapa, cmap=b, title='Celotno nebo', cbar=True, xsize=1400, unit='Gostota objektov [objektov/piksel]')     #izris mape
ct.mollaxes()
hp.graticule(coord=('E'))                                               #
예제 #42
0
cosmo_params = {
    l[0]: l[1]
    for l in zip(COSMO_PARAMS_NAMES, COSMO_PARAMS_MEANS)
}
params = {
    'output': OUTPUT_CLASS,
    'l_max_scalars': L_MAX_SCALARS,
    'lensing': LENSING
}
params.update(cosmo_params)
cosmo.set(params)
cosmo.compute()
cls = cosmo.lensed_cl(L_MAX_SCALARS)
eb_tb = np.zeros(shape=cls["tt"].shape)
I, Q, U = hp.synfast(
    (cls['tt'], cls['ee'], cls['bb'], cls['te'], eb_tb, eb_tb),
    nside=NSIDE,
    new=True)
print(cls["tt"].shape)
end_generation = time.clock() - start
cosmo.struct_cleanup()
cosmo.empty()

start = time.clock()
res = sphtfunc.map2alm((I, Q, U), lmax=L_MAX_SCALARS)
#res = sphtfunc.map2alm(U)
print(res.shape)
print(cls["tt"].shape)
end_back = time.clock() - start

s = 0
for l in range(0, 20):
예제 #43
0
 def setUp(self):
     self.lmax = 64
     self.path = os.path.dirname(os.path.realpath(__file__))
     self.map1 = [
         hp.ma(m) for m in hp.read_map(
             os.path.join(self.path, "data",
                          "wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits"),
             (0, 1, 2),
         )
     ]
     self.map2 = [
         hp.ma(m) for m in hp.read_map(
             os.path.join(self.path, "data",
                          "wmap_band_iqumap_r9_7yr_V_v4_udgraded32.fits"),
             (0, 1, 2),
         )
     ]
     self.mask = hp.read_map(
         os.path.join(
             self.path,
             "data",
             "wmap_temperature_analysis_mask_r9_7yr_v4_udgraded32.fits",
         )).astype(np.bool)
     for m in chain(self.map1, self.map2):
         m.mask = np.logical_not(self.mask)
     self.cla = hp.read_cl(
         os.path.join(
             self.path,
             "data",
             "cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter.fits",
         ))
     self.cl_fortran_nomask = hp.read_cl(
         os.path.join(
             self.path,
             "data",
             "cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter_nomask.fits",
         ))
     cls_file = pf.open(
         os.path.join(
             self.path,
             "data",
             "cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_IQU_lmax64_rmmono_3iter.fits",
         ))
     # fix for pyfits to read the file with duplicate column names
     for i in range(2, 6):
         cls_file[1].header["TTYPE%d" % i] += "-%d" % i
     cls = cls_file[1].data
     # order of HEALPIX is TB, EB while in healpy is EB, TB
     self.cliqu = [np.array(cls.field(i)) for i in (0, 1, 2, 3, 5, 4)]
     nside = 32
     lmax = 64
     fwhm_deg = 7.
     seed = 12345
     np.random.seed(seed)
     self.mapiqu = hp.synfast(
         self.cliqu,
         nside,
         lmax=lmax,
         pixwin=False,
         fwhm=np.radians(fwhm_deg),
         new=False,
     )
예제 #44
0
veccenter = hp.ang2vec(pi / 2 - np.radians(center[1]), np.radians(center[0]))
vecpix = hp.pix2vec(nside, np.arange(12 * nside ** 2))
cosang = np.dot(veccenter, vecpix)
maskok = np.degrees(np.arccos(cosang)) < maxang
msk_apo = nmt.mask_apodization(maskok, 1, apotype='C1')

# Select a binning scheme
b = nmt.NmtBin(nside, nlb=20, is_Dell=True)
leff = b.get_effective_ells()
# gaussian beam
beam = hp.gauss_beam(np.radians(0.39), lmax)

# initial maps and workspaces
mp_t, mp_q, mp_u = hp.synfast(spectra,
                              nside=nside,
                              fwhm=np.radians(0.39),
                              pixwin=True,
                              new=True,
                              verbose=False)

f0 = nmt.NmtField(msk_apo, [mp_t], beam=beam)
f2 = nmt.NmtField(msk_apo, [mp_q, mp_u], beam=beam)

# We initialize two workspaces for the fields:
w = nmt.NmtWorkspace()
w.compute_coupling_matrix(f0, f0, b)
w2 = nmt.NmtWorkspace()
w2.compute_coupling_matrix(f0, f2, b)

# We now iterate over several simulations,
# computing the power spectrum for each of them
data_00 = []
예제 #45
0
import matplotlib.pyplot as plt
import pymaster as nmt
import healpy as hp

np.random.seed(1234)

l, cltt, clee, clbb, clte, nltt, nlee, nlbb, nlte = np.loadtxt("cls_lss.txt",
                                                               unpack=True)
cltt[:2] = 0
fl = np.sqrt(l * (l + 1))
fl[0] = 1
fl = 1. / fl

nside_out = 64
# Generate spin-0 field
m = hp.synfast(cltt[:3 * nside_out], nside_out, new=True, verbose=False)
# Compute alm / sqrt(l*(l+1)) and then its derivatives
a = hp.map2alm(m)
a = hp.almxfl(a, fl)
_, mdth, mdph = hp.alm2map_der1(a, nside_out)

hp.write_map("mps_sp1.fits", [m, mdth, mdph], overwrite=True)

msk = np.ones_like(m)
f0 = nmt.NmtField(msk, [m], spin=0, n_iter=0)
f1 = nmt.NmtField(msk, [mdth, mdph], spin=1, n_iter=0)
cl00 = nmt.compute_coupled_cell(f0, f0)
cl01 = nmt.compute_coupled_cell(f0, f1)
cl11 = nmt.compute_coupled_cell(f1, f1)

msk = hp.read_map("msk.fits", verbose=False)
예제 #46
0
# Use random pointings for the test
p = create_random_pointings(center, 1000, 10)

# Polychromatic instrument model
q = QubicMultibandInstrument(filter_nus=nus * 1e9,
                             filter_relative_bandwidths=nus / deltas,
                             ripples=True) # The peaks of the synthesized beam are modeled with "ripples"

s = QubicScene(nside=nside, kind='IQU')

# Polychromatic acquisition model
a = QubicPolyAcquisition(q, p, s, effective_duration=2)

sp = read_spectra(0)
x0 = np.array(hp.synfast(sp, nside, new=True, pixwin=True)).T

TOD, maps_convolved = a.get_observation(x0)
maps_recon = a.tod2map(TOD, tol=tol)

cov = a.get_coverage().sum(axis=0)

mp.figure(1)
_max = [300, 5, 5]
for i, (inp, rec, iqu) in enumerate(zip(maps_convolved.T, maps_recon.T, 'IQU')):
    inp[cov < cov.max() * 0.01] = hp.UNSEEN
    rec[cov < cov.max() * 0.01] = hp.UNSEEN
    diff = inp - rec
    diff[cov < cov.max() * 0.01] = hp.UNSEEN
    hp.gnomview(inp, rot=center_gal, reso=5, xsize=700, fig=1,
        sub=(3, 3, i + 1), min=-_max[i], max=_max[i], title='Input, {}'.format(iqu))
예제 #47
0
    def setUp(self):
        fixture_name = os.path.splitext(os.path.basename(__file__))[0]
        self.outdir = create_outdir(self.comm, fixture_name)
        self.rank = 0
        self.ntask = 1
        if self.comm is not None:
            self.rank = self.comm.rank
            self.ntask = self.comm.size
        if self.rank == 0:
            for fname in glob.glob("{}/*".format(self.outdir)):
                try:
                    os.remove(fname)
                except OSError:
                    pass
        if self.comm is not None:
            self.comm.barrier()

        self.nobs = 1
        self.data = create_distdata(self.comm, obs_per_group=self.nobs)

        self.ndet = 4 * self.ntask
        self.sigma = 1
        self.rate = 50.0
        self.net = self.sigma / np.sqrt(self.rate)
        self.alpha = 2
        self.fknee = 1e0

        # Create detectors
        (
            dnames,
            dquat,
            depsilon,
            drate,
            dnet,
            dfmin,
            dfknee,
            dalpha,
        ) = boresight_focalplane(
            self.ndet,
            samplerate=self.rate,
            fknee=self.fknee,
            alpha=self.alpha,
            net=self.net,
            pairs=True,
        )

        # Pixelization
        self.sim_nside = 8
        self.map_nside = 8
        self.nnz = 3
        self.pointingmode = "IQU"[:self.nnz]

        # Samples per observation
        self.npix = 12 * self.sim_nside**2
        self.ninterval = 4
        self.totsamp = self.ninterval * self.npix

        # Define intervals with gaps in between
        intervals = []
        interval_length = self.npix
        istart = 0
        while istart < self.totsamp:
            istop = istart + interval_length
            interval_start = istart + 100
            interval_stop = istop - 100
            intervals.append(
                Interval(
                    start=interval_start / self.rate,
                    stop=interval_stop / self.rate,
                    first=interval_start,
                    last=interval_stop - 1,
                ))
            istart = istop

        # Construct an uncorrelated analytic noise model for the detectors

        noise = AnalyticNoise(
            rate=drate,
            fmin=dfmin,
            detectors=dnames,
            fknee=dfknee,
            alpha=dalpha,
            NET=dnet,
        )

        # Populate the observations

        for iobs in range(self.nobs):
            if iobs % 3 == 1:
                rot = qa.from_angles(np.pi / 2, 0, 0)
            elif iobs % 3 == 2:
                rot = qa.from_angles(np.pi / 2, np.pi / 2, 0)
            else:
                rot = None

            tod = TODHpixSpiral(
                self.data.comm.comm_group,
                dquat,
                self.totsamp,
                detranks=self.data.comm.group_size,
                rate=self.rate,
                nside=self.sim_nside,
                rot=rot,
            )

            self.data.obs[iobs]["tod"] = tod
            self.data.obs[iobs]["noise"] = noise
            self.data.obs[iobs]["intervals"] = intervals

            cflags = tod.local_common_flags()
            cflags[:] = 255
            for ival in tod.local_intervals(intervals):
                cflags[ival.first:ival.last + 1] = 0

            tod._az = (tod.local_times() % 100) / 100
            tod.scan_range = [0, 1, 0, 0]

            def read_boresight_az(self, local_start=0, n=None):
                if n is None:
                    n = self.local_samples[1] - local_start
                ind = slice(local_start, local_start + n)
                return tod._az[ind]

            tod.read_boresight_az = read_boresight_az.__get__(tod)

        self.npix = 12 * self.map_nside**2
        pix = np.arange(self.npix)
        pix = hp.reorder(pix, r2n=True)

        # Synthesize an input map
        self.lmax = 2 * self.sim_nside
        self.cl = np.ones([4, self.lmax + 1])
        self.cl[:, 0:2] = 0
        #self.cl[1:] = 0  # DEBUG
        fwhm = np.radians(10)
        self.inmap = hp.synfast(
            self.cl,
            self.sim_nside,
            lmax=self.lmax,
            mmax=self.lmax,
            pol=True,
            pixwin=True,
            fwhm=np.radians(30),
            verbose=False,
        )
        self.inmap = hp.reorder(self.inmap, r2n=True)
        self.inmapfile = os.path.join(self.outdir, "input_map.fits")
        hp.write_map(self.inmapfile, self.inmap, overwrite=True, nest=True)

        return
예제 #48
0
cl_file='/home/matt/wmap/simul_scalCls.fits'
radio_file='/data/wmap/faraday_MW_realdata.fits'
fwhm=[27.3,11.7]
bands=[43.1,94.5]
wl=np.array([299792458./(b*1e9) for b in bands])
fwhm_gen=[0,5,11.7,27.3,45,60]
nside=512
npix=hp.nside2npix(512)

cl_gen=hp.read_cl(cl_file)
alpha=hp.read_map(radio_file,hdu='maps/phi')
alpha=hp.ud_grade(alpha,nside)
const=2*(wl[0]**2-wl[1]**2)
plt.figure()
for f in fwhm_gen:
	simul_cmb=hp.synfast(cl_gen,nside,pol=1,new=1,fwhm=f*np.pi/(180.*60))
	rot_1=rotate_tqu(simul_cmb,wl[0],alpha)
	rot_2=rotate_tqu(simul_cmb,wl[1],alpha)
	Delta_Q=(rot_1[1]-rot_2[1])/const
	alpha_U=alpha*rot_1[2]

	dQ=hp.ma(Delta_Q)
	aU=hp.ma(alpha_U)
	dQ=hp.smoothing(dQ,fwhm=np.pi/180.)
	aU=hp.smoothing(dQ,fwhm=np.pi/180.)
	cls=hp.anafast(dQ,map2=aU)
	l=np.arange(len(cls))
	ll=np.array([i*(i+1)/(2*np.pi) for i in l])
	plt.plot(l[:384],ll[:384]*cls[:384]*1e12,'.',label='fwhm= {:2d}'.format(int(f)))
plt.legend(loc='upper right',numpoints=1)
plt.show()
예제 #49
0
import numpy as np
import healpy as hp

total = np.load('../simulation/Nside = 1024/noise_map.npy')
for n in range(20):
    #white_noise = np.load('/home/yao/Desktop/EM-smica/ABS/simulation/Nside = 1024/noise_map_NO%s.npy'%(n+2))
    white_noise = np.ones_like(total)
    cl_noise = np.ones((Nf, L + 1))
    Nl = (0.066**2, 0.065**2, 0.063**2, 0.028**2, 0.015**2, 0.023**2, 0.068**2)
    Nl_real = []
    Nl_matrix = []
    for i in range(Nf):
        cl_noise[i] = Nl[i]
        wn_j = hp.synfast(cl_noise[i], nside)
        for j in range(3):
            white_noise[i, j, :] = wn_j

        noise_power_spectrum = hp.anafast(white_noise[i][0], lmax=L, gal_cut=0)
        Nl_real.append(noise_power_spectrum)
    Nl_real = np.array(Nl_real)
    Nl_T = Nl_real.T
    for i in range(L):
        Nl_matrix.append(np.diag((Nl_T[i])))
    #np.save('/home/yao/Desktop/EM-smica/ABS/simulation/noise/noise_map_NO%s.npy'%(n+2), white_noise)
    np.save(
        '/home/yao/Desktop/EM-smica/ABS/simulation/Nside = 1024/noise_power_spectrum_NO%s.npy'
        % (n + 1), Nl_matrix)

    ##white_noise_masked = Mask(white_noise)
    #total_masked_power_spectrum = power_spectrum(total + white_noise,0)
    ##total_power_spectrum = power_spectrum(total + white_noise)
예제 #50
0
    hp.mollview(galP)
    hp.mollview(mask)
    plt.show()

    # load results of cleaning
    config_dict = pebbles.configurations.run[ARGS.name]
    res = pebbles.Residuals(**config_dict)

    if ARGS.cmb_gen:
        cl_config = pebbles.configurations.cos['planck2015']['params']
        class_cls = pebbles.pebbles.class_spectrum(cl_config)
        for i in range(nmc):
            synth_cmb = np.array(
                hp.synfast(class_cls,
                           res.nside,
                           pol=True,
                           new=True,
                           verbose=False,
                           fwhm=np.pi / 180. * fwhm / 60.))
            fname = "maps/nongaussian/cmb{:04d}_fwhm{:02d}amin.fits".format(
                i, int(fwhm))
            hp.write_map(fname, synth_cmb, overwrite=True)

    if ARGS.cmb_mc_stats:
        synth_map = np.empty((nmc, 2 * hp.nside2npix(res.nside)))
        for i in range(nmc):
            fname = "maps/nongaussian/cmb{:04d}_fwhm{:02d}amin.fits".format(
                i, int(fwhm))
            synth_map[i] = hp.read_map(fname, verbose=False,
                                       field=(1, 2)).ravel()

        skews = skew(synth_map, axis=1)
예제 #51
0
파일: noise.py 프로젝트: simonsobs/mapsims
    def simulate(
        self,
        tube,
        output_units="uK_CMB",
        seed=None,
        nsplits=1,
        mask_value=None,
        atmosphere=True,
        hitmap=None,
        white_noise_rms=None,
    ):
        """Create a random realization of the noise power spectrum

        Parameters
        ----------

        tube : str
            Specify a tube (for SO: ST0-ST3, LT0-LT6) see the `tubes` attribute
        output_units : str
            Output unit supported by PySM.units, e.g. uK_CMB or K_RJ
        seed : integer or tuple of integers, optional
            Specify a seed. The seed is converted to a tuple if not already
            one and appended to (0,0,6,tube_id) to avoid collisions between
            tubes, with the signal sims and with ACT noise sims, where
            tube_id is the integer ID of the tube.
        nsplits : integer, optional
            Number of splits to generate. The splits will have independent noise
            realizations, with noise power scaled by a factor of nsplits, i.e. atmospheric
            noise is assumed to average down with observing time the same way
            the white noise does. By default, only one split (the coadd) is generated.
        mask_value : float, optional
            The value to set in masked (unobserved) regions. By default, it uses
            the value in default_mask_value, which for healpix is healpy.UNSEEN
            and for CAR is numpy.nan.
        atmosphere : bool, optional
            Whether to include the correlated 1/f from the noise model. This is
            True by default. If it is set to False, then a pure white noise map
            is generated from the white noise power in the noise model, and
            the covariance between arrays is ignored.
        hitmap : string or map, optional
            Provide the path to a hitmap to override the default used for
            the tube. You could also provide the hitmap as an array
            directly.
        white_noise_rms : float or tuple of floats, optional
            Optionally scale the simulation so that the small-scale limit white noise
            level is white_noise_rms in uK-arcmin (either a single number or
            a pair for the dichroic array).

        Returns
        -------

        output_map : ndarray or ndmap
            Numpy array with the HEALPix or CAR map realization of noise.
            The shape of the returned array is (2,3,nsplits,)+oshape, where
            oshape is (npix,) for HEALPix and (Ny,Nx) for CAR.
            The first dimension of size 2 corresponds to the two different
            bands within a dichroic tube.
            See the `band_id` attribute of the Channel class
            to identify which is the index of a Channel in the array.

            The second dimension corresponds to independent split realizations
            of the noise, e.g. it is 1 for full mission.

            The third dimension corresponds to the three polarization
            Stokes components I,Q,U

            The last dimension is the number of pixels
        """
        assert nsplits >= 1
        if mask_value is None:
            mask_value = (default_mask_value["healpix"]
                          if self.healpix else default_mask_value["car"])

        # This seed tuple prevents collisions with the signal sims
        # but we should eventually switch to centralized seed
        # tracking.
        if seed is not None:
            try:
                iter(seed)
            except:
                seed = (seed, )
            tube_id = self.tubes[tube][0].tube_id
            seed = (0, 0, 6, tube_id) + seed
            np.random.seed(seed)

        # In the third row we return the correlation coefficient P12/sqrt(P11*P22)
        # since that can be used straightforwardly when the auto-correlations are re-scaled.
        ell, ps_T, ps_P, fsky, wnoise_power, weightsMap = self.get_noise_properties(
            tube,
            nsplits=nsplits,
            hitmap=hitmap,
            white_noise_rms=white_noise_rms,
            atmosphere=atmosphere,
        )

        if not (atmosphere):
            if self.apply_beam_correction:
                raise NotImplementedError(
                    "Beam correction is not currently implemented for pure-white-noise sims."
                )
            # If no atmosphere is requested, we use a simpler/faster method
            # that generates white noise in real-space.
            if self.healpix:
                ashape = (hp.nside2npix(self.nside), )
                sel = np.s_[:, None, None, None]
                pmap = self.pixarea_map
            else:
                ashape = self.shape[-2:]
                sel = np.s_[:, None, None, None, None]
                pmap = pixell.enmap.enmap(self.pixarea_map, self.wcs)
            spowr = np.sqrt(wnoise_power[sel] / pmap)
            output_map = spowr * np.random.standard_normal(
                (self.channel_per_tube, nsplits, 3) + ashape)
            output_map[:, :, 1:, :] = output_map[:, :, 1:, :] * np.sqrt(2.0)
        else:
            if self.healpix:
                npix = hp.nside2npix(self.nside)
                output_map = np.zeros(
                    (self.channel_per_tube, nsplits, 3, npix))
                for i in range(nsplits):
                    for i_pol in range(3):
                        output_map[:, i, i_pol] = np.array(
                            hp.synfast(
                                ps_T if i_pol == 0 else ps_P,
                                nside=self.nside,
                                pol=False,
                                new=True,
                                verbose=False,
                            ))
            else:
                output_map = pixell.enmap.zeros((2, nsplits, 3) + self.shape,
                                                self.wcs)
                ps_T = pixell.powspec.sym_expand(np.asarray(ps_T),
                                                 scheme="diag")
                ps_P = pixell.powspec.sym_expand(np.asarray(ps_P),
                                                 scheme="diag")
                # TODO: These loops can probably be vectorized
                for i in range(nsplits):
                    for i_pol in range(3):
                        output_map[:, i, i_pol] = pixell.curvedsky.rand_map(
                            (self.channel_per_tube, ) + self.shape,
                            self.wcs,
                            ps_T if i_pol == 0 else ps_P,
                            spin=0,
                        )

        for i in range(self.channel_per_tube):
            freq = self.tubes[tube][i].center_frequency
            if not (self.homogeneous):
                good = weightsMap[i] != 0
                # Normalize on the Effective sky fraction, see discussion in:
                # https://github.com/simonsobs/mapsims/pull/5#discussion_r244939311
                output_map[i, :, :,
                           good] /= np.sqrt(weightsMap[i][good][..., None,
                                                                None])
                output_map[i, :, :, np.logical_not(good)] = mask_value
            unit_conv = (1 * u.uK_CMB).to_value(
                u.Unit(output_units), equivalencies=u.cmb_equivalencies(freq))
            output_map[i] *= unit_conv
        return output_map
예제 #52
0
vecpix = hp.pix2vec(nside,np.arange(12*nside**2))
cosang = np.dot(veccenter,vecpix)
maskok = np.degrees(np.arccos(cosang)) < maxang
maskmap=np.zeros(12*nside**2)
maskmap[maskok]=1

wl = hp.anafast(maskmap,regression=False)
wl = wl[0:lmax+1]


#### Do a Monte-Carlo
nbmc = 1000
allcls = np.zeros((nbmc, lmax+1))
for i in np.arange(nbmc):
	print(i)
	map = hp.synfast(spectra[1],nside,fwhm=0,pixwin=True,new=True)
	allcls[i,:]  = hp.anafast(map*maskmap)


#### Mll Matrix
Mll = Mllmatrix(lmax, wl)

#### ell binning
min_ell = 20
deltal = 30
all_ell = min_ell-1 + np.arange(1000)*deltal
max_ell = np.max(all_ell[all_ell < lmax])
nbins = (max_ell + 1 - min_ell) / deltal
ell_low = min_ell + np.arange(nbins)*deltal
ell_hi = ell_low + deltal - 1
the_ell = np.arange(lmax+1)
예제 #53
0
plt.savefig(survey+'_region.png',format='png')
plt.savefig(survey+'_region.eps',format='eps')
plt.clf()
plt.close()
fsky= 1. - np.sum(mask_bool)/float(len(mask_bool))	
L=np.sqrt(fsky*4*np.pi)
dl_eff=2*np.pi/L


print('\tGenerating Control Map')
alpha_radio=hp.read_map(alpha_file,hdu='maps/phi',verbose=False)
tmp_alpha=hp.ud_grade(alpha_radio,nside_in)
alpha_radio=hp.read_map(alpha_file,hdu='maps/phi',verbose=False)
sigma_alpha=hp.read_map(alpha_file,hdu='uncertainty/phi',verbose=False)

iqu_cmb=hp.synfast(cmb_cls,new=1,fwhm=0,pol=1,nside=nside_in,verbose=False)
iqu_array=[rotate_tqu.rotate_tqu(iqu_cmb,w,tmp_alpha) for w in wl] 

iqu_array = [ np.array([iqu[0], \
	iqu[1] + np.copy(simul_sync_q*sync_factor[i] + simul_dust_q*dust_factor[i]), iqu[2] + np.copy(simul_sync_u*sync_factor[i] + simul_dust_u*dust_factor[i])]) for i,iqu in enumerate(iqu_array)] 

iqu_array= [ hp.smoothing(iqu,pol=1,fwhm=beam_fwhm[cnt]*np.pi/(180.*60.),verbose=False) for cnt,iqu in enumerate(iqu_array)]
#iqu_array_fr= [ hp.smoothing(iqu,pol=1,fwhm=beam_fwhm[cnt]*np.pi/(180.*60.),verbose=False) for cnt,iqu in enumerate(iqu_array_fr)]

iqu_back=np.copy(iqu_array)
const_array=[]
band_names=[]
the_au_index=[]
au_index=[]
for i in xrange(len(bands)-1):
	for j in xrange(i+1,len(bands)):
    return np.std(map_masked, axis=0)

p_name = options.param
p_val  = options.value
print p_name, "=", p_val

nrealizations = 1
ItoQU = np.zeros((nrealizations, 4, 3))
Noise = np.zeros((nrealizations, 4, 3))
QUmix = np.zeros((nrealizations, 4, 3))
for realization in xrange(nrealizations):
    seed = int(options.seed) + realization
    print seed
    np.random.seed(seed)
    spectra = read_spectra(0)
    input_map = np.array(hp.synfast(spectra, nside)).T
    ItoQU_, Noise_, QUmix_, o, e = run_ss(p_name, p_val, input_map)
    ItoQU[realization] = ItoQU_
    Noise[realization] = Noise_
    QUmix[realization] = QUmix_
dict = {p_name: p_val,
        'ItoQU': ItoQU,
        'Noise': Noise,
        'QUmix': QUmix,
        'Omega': o,
        'Eta': e}
if rank == 0:
    f_name = 'scan_ss_' + p_name + str(p_val) + 'seed' + str(options.seed) +'.pkl'
    with open(f_name, 'w') as f:
        dump(dict, f)
예제 #55
0
# Polychromatic instrument model
q = QubicMultibandInstrument(filter_nus=nus * 1e9,
                             filter_relative_bandwidths=nus / deltas,
                             ripples=True) # The peaks of the synthesized beam are modeled with "ripples"

s = QubicScene(nside=nside, kind='IQU')

# Multi-band acquisition model
# Nsb=2 sub-bands to reconstruct the CMB
Nsb = 2
Nbfreq, nus_edge, nus_, deltas_, Delta_, Nbbands_ = compute_freq(band, relative_bandwidth, Nsb)
a = QubicMultibandAcquisition(q, p, s, nus_edge, effective_duration=2)

# Generate the input CMB map
sp = read_spectra(0)
cmb = np.array(hp.synfast(sp, nside, new=True, pixwin=True)).T

# Generate the dust map
coef = 1.39e-2
ell = np.arange(1, 1000)
fact = (ell * (ell + 1)) / (2 * np.pi)
spectra_dust = [np.zeros(len(ell)), 
                coef * (ell / 80.)**(-0.42) / (fact * 0.52), 
                coef * (ell / 80.)**(-0.42) / fact, 
                np.zeros(len(ell))]
dust = np.array(hp.synfast(spectra_dust, nside, new=True, pixwin=True)).T

# Combine CMB and dust. As output we have N 3-component maps of sky.
x0 = cmb_plus_dust(cmb, dust, Nbbands, nus)

# Simulate the TOD. Here we use Nf frequencies over the 150 GHz band
예제 #56
0
파일: vksz.py 프로젝트: amanzotti/vksz
def cross_template_with_planck(template, nrandom=0):
    #band='mb'
    band=217

    
    # get mask
    mask = load_planck_mask()
    mask_factor = np.mean(mask**2.)

    # get planck beam
    bl, l_bl = load_planck_bl(band)
    l_bl = l_bl[0:lmax+1]
    bl = bl[0:lmax+1]

    # get CL_PLANCK_THEORY
    l_planck, cl_planck = get_cl_theory(band)
    # store a version of the biased, beam-convolved spectrum.
    cl_planck_biased = cl_planck.copy()
    # "unbias" this spectrum, i.e. correct for Planck beam
    cl_planck /= (bl**2.)

    # Define how we'll weight the differnet multipoles.
    # Since we've already gone from 2d to 1d power spectrum, we
    # need to weight by nmodes=2L+1.
    weight = (2.*l_planck+1.)/cl_planck
    weight[0:10] = 0.
    
    # get template auto-spectrum
    cl_template = hp.anafast(template*mask, lmax=lmax)/mask_factor
    
    # estimate amplitude(s)
    amps = []
    if (nrandom==0):
        print ' '
        print 'data'
        planck = load_planck_data(band)
        cl_template_planck = hp.anafast(template*mask, map2=planck*mask, lmax=lmax)/mask_factor
        # correct by one power of planck beam function
        cl_template_planck /= bl
        amp = np.sum(cl_template_planck*weight)/np.sum(cl_template*weight)
        print '%0.3f'%amp
        print amp
        amps.append(amp)
    else:
        print ' '
        print 'randoms'
        # loop over nrandom
        for irandom in range(nrandom):
            print '%i/%i'%(irandom,nrandom)
            # generate a Planck map.
            # it's roundabout to generate a map from some CL's, then calculate
            # alm's to cross with the template.  why not directly generate alm's?
            # because i want to include the effect of multiplying by the real-space mask.
            planck = hp.synfast(cl_planck_biased, nside, lmax=lmax)
            cl_template_planck = hp.anafast(template*mask, map2=planck*mask, lmax=lmax)/mask_factor
            # correct by one power of planck beam function
            cl_template_planck /= bl
            amp = np.sum(cl_template_planck*weight)/np.sum(cl_template*weight)
            print '%0.3f'%amp
            print amp
            amps.append(amp)
            print 'current RMS:'
            print np.std(amps)


    # return list of amplitudes
    return amps
예제 #57
0
def add_gaussian_small_scales(map_in, nside_out, pol=False):
    cl_in = hp.anafast(map_in)
    map_in_ns_out = hp.ud_grade(map_in, nside_out)
    map_in_ns_out_smt = hp.smoothing(map_in_ns_out,
                                     fwhm=np.radians(180. / 1000.))
    print('map smoothed')
    ell_to_fit = np.arange(100, 500)
    hpf = create_high_pass_filter(300, 1000, 4 * nside_out)
    ell_hell = np.arange(len(hpf))
    if pol == False:
        cl_T_to_fit = cl_in[ell_to_fit]
    else:
        cl_T_to_fit = cl_in[0][ell_to_fit]
    fit_cl_T = np.polyfit(np.log(ell_to_fit), np.log(cl_T_to_fit), 1)
    cl_hell_T = np.exp(fit_cl_T[0] * np.log(ell_hell) + fit_cl_T[1]) * hpf
    cl_hell_T[0] = 0
    cl_hell_zero = np.zeros(len(cl_hell_T))
    if pol:
        cl_E_to_fit = cl_in[1][ell_to_fit]
        cl_B_to_fit = cl_in[2][ell_to_fit]
        fit_cl_E = np.polyfit(np.log(ell_to_fit), np.log(cl_E_to_fit), 1)
        fit_cl_B = np.polyfit(np.log(ell_to_fit), np.log(cl_B_to_fit), 1)
        cl_hell_E = np.exp(fit_cl_E[0] * np.log(ell_hell) + fit_cl_E[1]) * hpf
        cl_hell_B = np.exp(fit_cl_B[0] * np.log(ell_hell) + fit_cl_B[1]) * hpf
        cl_hell_E[0] = 0
        cl_hell_B[0] = 0
        cl_hell = np.array([
            cl_hell_T, cl_hell_E, cl_hell_B, cl_hell_zero, cl_hell_zero,
            cl_hell_zero
        ])
        map_ss = hp.synfast(cl_hell,
                            nside_out,
                            lmax=nside_out * 3,
                            pol=True,
                            new=True)
    else:
        map_ss = hp.synfast(cl_hell_T, nside_out, lmax=nside_out * 3)
    print('map small scales computed')
    map_ss_mod = map_ss * map_in_ns_out_smt
    if pol == False:
        coeff_T = np.std(map_ss_mod) / np.std(map_ss)
        map_out_T = map_ss_mod / coeff_T + map_in_ns_out_smt
    else:
        coeff_T = np.std(map_ss_mod[0]) / np.std(map_ss[0])
        map_out_T = map_ss_mod[0] / coeff_T + map_in_ns_out_smt[0]
    if np.any(map_out_T < 0):
        negative_pix = np.where(map_out_T < 0)[0]
        print('negative pixels ', len(negative_pix))
        if pol == False:
            map_out_T[negative_pix] = map_in_ns_out[negative_pix]
        else:
            map_out_T[negative_pix] = map_in_ns_out[0][negative_pix]
    if pol:
        coeff_Q = np.std(map_ss_mod[1]) / np.std(map_ss[1])
        coeff_U = np.std(map_ss_mod[2]) / np.std(map_ss[2])
        coeff_P = (coeff_Q + coeff_U) / 2.
        map_out_Q = map_ss_mod[1] / coeff_P + map_in_ns_out_smt[1]
        map_out_U = map_ss_mod[2] / coeff_P + map_in_ns_out_smt[2]
        map_out = np.array([map_out_T, map_out_Q, map_out_U])
    else:
        map_out = map_out_T
    return map_out
예제 #58
0
    for g in range(0, 11):

        almtemp = h.map2alm(n.zeros(len(truediffCRmap)), lmax=lmax)
        almtemp[h.sphtfunc.Alm.getidx(lmax=lmax, l=1, m=0)] = g
        almtemp[h.sphtfunc.Alm.getidx(lmax=lmax, l=1, m=1)] = 10 - g
        truediffCRmap = h.alm2map(almtemp, nside, lmax=lmax)
        truediffCRmap *= 1e-2 / max(truediffCRmap)
        almtemp = h.map2alm(truediffCRmap)

        Cldipole = h.anafast(truediffCRmap, lmax=lmax)
        dipolepower = Cldipole[1]
        Cltrue = n.zeros(len(Cldipole))
        Cltrue[0] = 0.0  # no monopole
        for i in range(1, lmax + 1):
            Cltrue[i] = 18 * dipolepower / (2. * i + 1.) / (i + 1.) / (i + 2.)
        psmap = h.synfast(Cltrue, 64, lmax=lmax)
        psalm = h.map2alm(psmap, lmax=lmax)

        psalm[h.sphtfunc.Alm.getidx(
            lmax=lmax, l=1, m=0)] = almtemp[h.sphtfunc.Alm.getidx(lmax=lmax,
                                                                  l=1,
                                                                  m=0)]
        psalm[h.sphtfunc.Alm.getidx(
            lmax=lmax, l=1, m=1)] = almtemp[h.sphtfunc.Alm.getidx(lmax=lmax,
                                                                  l=1,
                                                                  m=1)]
        truediffCRmap = h.alm2map(psalm, 64, lmax=lmax)

        h.write_map(sourcefolder + "true_relint_dipole%02d.fits.gz" % g,
                    truediffCRmap)
예제 #59
0
## Covariance matrix
covmc=FitsArray('covmc'+str(signoise)+'_'+str(nbmc)+'.dat')
cormc=FitsArray('cormc'+str(signoise)+'_'+str(nbmc)+'.dat')
###########################################################

##### build coverage
a=np.loadtxt('./cl_r=0.1bis2.txt')
ell=a[:,0]
ctt=np.concatenate([[0,0],a[:,1]*1e12*2*np.pi/(ell*(ell+1))])
cee=np.concatenate([[0,0],a[:,2]*1e12*2*np.pi/(ell*(ell+1))])
cte=np.concatenate([[0,0],a[:,4]*1e12*2*np.pi/(ell*(ell+1))])
cbb=np.concatenate([[0,0],a[:,7]*1e12*2*np.pi/(ell*(ell+1))])
ell=np.concatenate([[0,1],ell])
spectra=[ell,ctt,cte,cee,cbb]
nside=128
map_orig=hp.synfast(spectra[4],nside,fwhm=0,pixwin=True)
input_map=map_orig.copy()
kmax = 2
qubic = QubicInstrument('monochromatic,nopol',nside=128)
obs = QubicConfiguration(qubic, pointings)
C = obs.get_convolution_peak_operator()
P = obs.get_projection_peak_operator(kmax=kmax)
H = P * C
tod = H(input_map)
coverage = P.T(np.ones_like(tod))





# study covariance matrix