def get_beam_dic(freqs, beam_noise_dic, lmax, opbeam=None, make_2d=0, mapparams=None): bl_dic = {} for freq in freqs: beamval, noiseval = beam_noise_dic[freq] bl_dic[freq] = H.gauss_beam(np.radians(beamval / 60.), lmax=lmax - 1) if make_2d: assert mapparams is not None el = np.arange(len(bl_dic[freq])) bl_dic[freq] = flatsky.cl_to_cl2d(el, bl_dic[freq], mapparams) if opbeam is not None: bl_dic['effective'] = H.gauss_beam(np.radians(opbeam / 60.), lmax=lmax - 1) if make_2d: assert mapparams is not None bl_dic['effective'] = flatsky.cl_to_cl2d(el, bl_dic['effective'], mapparams) return bl_dic
def __init__(self, mask_in, nside, bin_w, lmin, lmax, beams, wsp = True): ''' class for Band-Power-Estimation; Define the **apodized mask**, **beam weights**, **nside**, **bin-scheme**, **ell** ------------------------ beams : a numpy array which include fwhms for every frequency. Deconvolve to ** lmax=2*nside ** ''' self.mask = nmt.mask_apodization(mask_in, 6, apotype='C2') self.nside = nside; self.lmax = lmax; self.Nf = len(beams); self.beams = beams; # self.beam = hp.gauss_beam(beams/60/180*np.pi, lmax = 3*self.nside); # self.b = nmt.NmtBin(self.nside, nlb=bin_w, lmax=self.lmax, is_Dell = True) self.b = self.bands(bin_w = bin_w, lmin = lmin, lmax = lmax); self.ell_n = self.b.get_effective_ells(); self.lbin = len(self.ell_n) # self.w00 = []; # self.w02 = []; self.w22 = []; # - To construct a empty template with a mask to calculate the **coupling matrix** if wsp is True: qu = np.ones((2, 12*self.nside**2)) for i in range(self.Nf): beam_i = hp.gauss_beam(beams[i]/60/180*np.pi, lmax = 3*self.nside - 1); # m0 = nmt.NmtField(self.mask,[qu[0]],purify_e=False, purify_b=True, beam = beam_i); # # construct a workspace that calculate the coupling matrix first. # _w00 = nmt.NmtWorkspace() # _w00.compute_coupling_matrix(m0, m0, self.b) ## spin-0 with spin-0 # self.w00.append(_w00); for j in range(self.Nf): beam_j = hp.gauss_beam(beams[j]/60/180*np.pi, lmax = 3*self.nside - 1); m20 = nmt.NmtField(self.mask, qu, purify_e=False, purify_b=True, beam = beam_i); m21 = nmt.NmtField(self.mask, qu, purify_e=False, purify_b=True, beam = beam_j); # _w02 = nmt.NmtWorkspace() # _w02.compute_coupling_matrix(m0, m21, self.b) ## spin-0 with spin-2 _w22 = nmt.NmtWorkspace() _w22.compute_coupling_matrix(m20, m21, self.b) ## spin-2 with spin-2 # self.w02.append(_w02); self.w22.append(_w22)
def get_fields(self, map, mask_apo=None, purify_e=False, purify_b=True, beam_correction=None): """ Parameters ---------- map: array IQU maps, shape (3, #pixels) mask_apo: array, optionnal (if not given the one used at the object's instanciation is used) Apodized mask. purify_e: bool, optional False by default. purify_b: bool, optional True by default. Note that generally it's not a good idea to purify both, since you'll lose sensitivity on E beam_correction: bool, optional None by default. If True, a correction by the Qubic beam at 150GHz is applied. You can also give the beam FWHM you want to correct for. Returns ------- f0, f2: spin-0 and spin-2 Namaster fields. """ # The maps may contain hp.UNSEEN - They must be replaced with zeros undefpix = map == hp.UNSEEN map[undefpix] = 0 mp_t, mp_q, mp_u = map nside = hp.npix2nside(len(mp_t)) if mask_apo is None: mask_apo = self.mask_apo if beam_correction is not None: if beam_correction is True: # Default value for QUBIC at 150 GHz beam = hp.gauss_beam(np.deg2rad(0.39268176), lmax=3 * nside - 1) else: beam = hp.gauss_beam(np.deg2rad(beam_correction), lmax=3 * nside - 1) else: beam = None f0 = nmt.NmtField(mask_apo, [mp_t], beam=beam) f2 = nmt.NmtField(mask_apo, [mp_q, mp_u], purify_e=purify_e, purify_b=purify_b, beam=beam) self.f0 = f0 self.f2 = f2 return f0, f2
def crosWSP_TT(self, maps, beams=[None,None]): # assemble NaMaster fields if beams[0] is None: f01 = nmt.NmtField(self._apomask, [maps[0]]) else: f01 = nmt.NmtField(self._apomask, [maps[0]], beam=hp.gauss_beam(beams[0], 3*self._nside-1)) if beams[1] is None: f02 = nmt.NmtField(self._apomask, [maps[3]]) else: f02 = nmt.NmtField(self._apomask, [maps[3]], beam=hp.gauss_beam(beams[1], 3*self._nside-1)) # prepare workspace w = nmt.NmtWorkspace() w.compute_coupling_matrix(f01, f02, self._b) return w
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
def get_isocov(params, exp, LD_res, HD_res=14, pyFFTWthreads=4): """ Set HD_res to 14 for full sky sampled at res LD. """ #sN_uKamin, sN_uKaminP, Beam_FWHM_amin, ellmin, ellmax = get_config(exp) sN_uKamin = params.sN_uKamin sN_uKaminP = params.sN_uKaminP Beam_FWHM_amin = params.Beam_FWHM_amin ellmin = params.lmin ellmax = params.lmax cls_unl, cls_len = get_fidcls(ellmax_sky=ellmax_sky,path_to_inputs=path_to_inputs) cls_noise = {} cls_noise['t'] = (sN_uKamin * np.pi / 180. / 60.) ** 2 * np.ones(ellmax_sky + 1) # simple flat noise Cls cls_noise['q'] = (sN_uKaminP * np.pi / 180. / 60.) ** 2 * np.ones(ellmax_sky + 1) # simple flat noise Cls cls_noise['u'] = (sN_uKaminP * np.pi / 180. / 60.) ** 2 * np.ones(ellmax_sky + 1) # simple flat noise Cls cl_transf = hp.gauss_beam(Beam_FWHM_amin / 60. * np.pi / 180., lmax=ellmax_sky) lib_alm = ffs_covs.ell_mat.ffs_alm_pyFFTW(get_ellmat(LD_res, HD_res=HD_res), filt_func=lambda ell: (ell >= ellmin) & (ell <= ellmax), num_threads=pyFFTWthreads) lib_skyalm = ffs_covs.ell_mat.ffs_alm_pyFFTW(get_ellmat(LD_res, HD_res=HD_res), filt_func=lambda ell: (ell <= ellmax_sky), num_threads=pyFFTWthreads) if os.path.exists('/global'): lib_dir = '/global/cscratch1/sd/markm/lensit/temp/Covs/%s/LD%sHD%s' % (exp, LD_res, HD_res) else: lib_dir = '/media/sf_C_DRIVE/Users/DarkMatter42/OneDrive - University of Sussex/LensIt/temp/Covs/%s/LD%sHD%s' % (exp, LD_res, HD_res) return ffs_covs.ffs_cov.ffs_diagcov_alm(lib_dir, lib_alm, cls_unl, cls_len, cl_transf, cls_noise, lib_skyalm=lib_skyalm)
def test_gauss_beam(self): idl_gauss_beam = np.array( pf.open( os.path.join(self.path, 'data', 'gaussbeam_10arcmin_lmax512_pol.fits'))[0].data).T gauss_beam = hp.gauss_beam(np.radians(10. / 60.), lmax=512, pol=True) np.testing.assert_allclose(idl_gauss_beam, gauss_beam)
def test_gauss_beam(self): with pf.open( os.path.join(self.path, "data", "gaussbeam_10arcmin_lmax512_pol.fits")) as f: idl_gauss_beam = np.array(f[0].data).T gauss_beam = hp.gauss_beam(np.radians(10.0 / 60.0), lmax=512, pol=True) np.testing.assert_allclose(idl_gauss_beam, gauss_beam)
def get_isocov(exp, LD_res, HD_res=14, pyFFTWthreads=4): """ Set HD_res to 14 for full sky sampled at res LD. """ sN_uKamin, sN_uKaminP, Beam_FWHM_amin, ellmin, ellmax = get_config(exp) cls_unl, cls_len = get_fidcls(ellmax_sky=ellmax_sky) cls_noise = {} cls_noise['t'] = (sN_uKamin * np.pi / 180. / 60.)**2 * np.ones( ellmax_sky + 1) # simple flat noise Cls cls_noise['q'] = (sN_uKaminP * np.pi / 180. / 60.)**2 * np.ones( ellmax_sky + 1) # simple flat noise Cls cls_noise['u'] = (sN_uKaminP * np.pi / 180. / 60.)**2 * np.ones( ellmax_sky + 1) # simple flat noise Cls cl_transf = hp.gauss_beam(Beam_FWHM_amin / 60. * np.pi / 180., lmax=ellmax_sky) lib_alm = ffs_covs.ell_mat.ffs_alm_pyFFTW( get_ellmat(LD_res, HD_res=HD_res), filt_func=lambda ell: (ell >= ellmin) & (ell <= ellmax), num_threads=pyFFTWthreads) lib_skyalm = ffs_covs.ell_mat.ffs_alm_pyFFTW(get_ellmat(LD_res, HD_res=HD_res), filt_func=lambda ell: (ell <= ellmax_sky), num_threads=pyFFTWthreads) lib_dir = LENSITDIR + '/temp/Covs/%s/LD%sHD%s' % (exp, LD_res, HD_res) return ffs_covs.ffs_cov.ffs_diagcov_alm(lib_dir, lib_alm, cls_unl, cls_len, cl_transf, cls_noise, lib_skyalm=lib_skyalm)
def GetTauMap(tmap, cltt, nltt, nside=None, lmax=None, mmax=None, fwhm=0., pixwin=False): if nside is None: nside = hp.npix2nside(tmap.size) if lmax is None: lmax = 2 * nside assert (len(cltt) >= lmax + 1) assert (len(nltt) >= lmax + 1) talm = hp.map2alm(tmap, lmax=lmax, mmax=mmax) if fwhm != 0.: bl = hp.gauss_beam(np.radians(fwhm / 60.), lmax=lmax) talm = hp.almxfl(talm, bl, mmax=mmax) fl1 = cltt / (cltt + nltt) # probably nltt has to be divided by bl fl2 = 1. / (cltt + nltt) # probably nltt has to be divided by bl fl1[:2] = 0. fl2[:2] = 0. alm1 = hp.almxfl(talm, fl1, mmax=mmax) alm2 = hp.almxfl(talm, fl2, mmax=mmax) return hp.alm2map( alm1, nside, lmax=lmax, mmax=mmax, pixwin=pixwin, fwhm=fwhm) * hp.alm2map( alm2, nside, lmax=lmax, mmax=mmax, pixwin=pixwin, fwhm=fwhm)
def _get_alms(data, beams=None, lmax=None, weights=None, iter=3): alms = [] for f, fdata in enumerate(data): if weights is None: alms.append(hp.map2alm(fdata, lmax=lmax, iter=iter)) else: alms.append( hp.map2alm(hp.ma(fdata) * weights, lmax=lmax, iter=iter)) logging.info(f"{f+1} of {len(data)} complete") alms = np.array(alms) if beams is not None: logging.info('Correcting alms for the beams') for fwhm, alm in zip(beams, alms): bl = hp.gauss_beam(np.radians(fwhm / 60.0), lmax, pol=(alm.ndim == 2)) if alm.ndim == 1: alm = [alm] bl = [bl] for i_alm, i_bl in zip(alm, bl.T): hp.almxfl(i_alm, 1.0 / i_bl, inplace=True) return alms
def alms_from_maps(maps, beams=None): """ Function to get alms from healpix maps. Correct for the beams (if any). Beams are assumed to be gaussian. Parameters ---------- maps : list list containing the frequency maps that can have different nside beams : ndarray beams associated with each map (assumed gaussian) Returns ------- alms : ndarray array storing the spherical harmonic transform of each freq map. Shape is ``(freqs, lm, ri)`` """ if not isinstance(maps, list): maps = [maps] lmax_maps_list = [3 * hp.get_nside(fmap) - 1 for fmap in maps] lmax = min(lmax_maps_list) alms = [] for f, fmaps in enumerate(maps): alms.append(hp.map2alm(fmaps, lmax=lmax)) if beams is not None: for fwhm, alm in zip(beams, alms): lmax = hp.Alm.getlmax(len(alm)) bl = hp.gauss_beam(np.radians(fwhm / 60.0), lmax) for i_alm, i_bl in zip(alm, bl.T): hp.almxfl(i_alm, 1.0 / i_bl, inplace=True) return np.array(alms)
def deconv_planet(matrix, planet='', w_cutsky=None, masks_means=None): lmax = np.size(matrix, 0) - 1 n1 = np.size(matrix, 1) n2 = np.size(matrix, 2) factor = 1.17741 / 60 # turns radius in arcsec into FWHM in arcmin am2rad = np.radians(1 / 60) # turns arcmin into radians if planet == 'Saturn': # 9.50'' #wl_planet = qb.spectra.blm_cl(qb.blm_gauss(9.50*factor, lmax)) wl_planet = (hp.gauss_beam(9.50 * factor * am2rad, lmax=lmax))**2 else: wl_planet = np.ones((lmax + 1), dtype=type(1.)) print(prefix, planet + ' (2000) ', wl_planet[2000].flatten(), flush=True) for i in range(n1): for j in range(n2): matrix[:, i, j] /= wl_planet if w_cutsky is not None: print(prefix, 'W cut sky (2000) ', w_cutsky[:, :, 2000].flatten(), flush=True) for i in range(n1): for j in range(n2): matrix[:, i, j] *= w_cutsky[i, j, :] if masks_means is not None: print(prefix, 'masks means', masks_means.flatten(), flush=True) for i in range(n1): for j in range(n2): matrix[:, i, j] /= masks_means[i, j] return matrix
def rspectrum(nu, r, sig, scaling=1.0): """ Calculates the CMB amplituded given a value of r and requested modes """ import camb from camb import model, initialpower import healpy as hp #Set up a new set of parameters for CAMB 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.5, ombh2=0.022, omch2=0.122, mnu=0.06, omk=0, tau=0.06) pars.InitPower.set_params(As=2e-9, ns=0.965, r=r) lmax=6000 pars.set_for_lmax(lmax, lens_potential_accuracy=0) pars.WantTensors = True results = camb.get_results(pars) powers = results.get_cmb_power_spectra(params=pars, lmax=lmax, CMB_unit='muK', raw_cl=True,) l = np.arange(2,lmax+1) if sig == "TT": cl = powers['unlensed_scalar'] signal = 0 elif sig == "EE": cl = powers['unlensed_scalar'] signal = 1 elif sig == "BB": cl = powers['tensor'] signal = 2 bl = hp.gauss_beam(40/(180/np.pi*60), lmax,pol=True) A = np.sqrt(sum( 4*np.pi * cl[2:,signal]*bl[2:,signal]**2/(2*l+1) )) return cmb(nu, A*scaling)
def get_noisefree_maps_lib_for_MCN1(params, exp, LDres, HDres=14, cache_lenalms=True, cache_maps=False, nsims=120, num_threads=4,path_to_inputs='.'): """ Default simulation library of 120 full flat sky sims with no instrument noise at resolution LDres. Different exp at same resolution share the same random phases both in CMB and noise Will build all phases at the very first call if not already present. :param exp: 'Planck', 'S4' ... See get_config :param LDres: 14 : cell length is 0.745 amin, 13 : 1.49 etc. :return: sim library instance """ #_, _, Beam_FWHM_amin, ellmin, ellmax = get_config(exp) Beam_FWHM_amin = params.Beam_FWHM_amin ellmin = params.lmin ellmax = params.lmax len_cmbs = get_lencmbs_lib_for_MCN1(res=HDres, cache_sims=cache_lenalms, nsims=nsims,path_to_inputs=path_to_inputs, Beam_FWHM_amin=Beam_FWHM_amin) lmax_sky = len_cmbs.lib_skyalm.ellmax cl_transf = hp.gauss_beam(Beam_FWHM_amin / 60. * np.pi / 180., lmax=lmax_sky) lib_datalm = ffs_covs.ell_mat.ffs_alm_pyFFTW(get_ellmat(LDres, HDres), filt_func=lambda ell: ell <= lmax_sky, num_threads=num_threads) fsky = int(np.round(np.prod(len_cmbs.lib_skyalm.ell_mat.lsides) / 4. / np.pi * 1000.)) vcell_amin2 = np.prod(lib_datalm.ell_mat.lsides) / np.prod(lib_datalm.ell_mat.shape) * (180 * 60. / np.pi) ** 2 if os.path.exists('/global'): pixpha = sims.ffs_phas.pix_lib_phas('/global/cscratch1/sd/markm/lensit/temp/%s_sims/fsky%04d/beam%d/res%s/pixpha' % (nsims, fsky, Beam_FWHM_amin*10, LDres), 3, lib_datalm.ell_mat.shape, nsims_max=nsims) else: pixpha = sims.ffs_phas.pix_lib_phas('/media/sf_C_DRIVE/Users/DarkMatter42/OneDrive - University of Sussex/LensIt/temp/%s_sims/fsky%04d/beam%d/res%s/pixpha' % (nsims, fsky, Beam_FWHM_amin*10, LDres), 3, lib_datalm.ell_mat.shape, nsims_max=nsims) if not pixpha.is_full() and pbs.rank == 0: for _i, idx in misc.misc_utils.enumerate_progress(np.arange(nsims), label='Generating Noise phases'): pixpha.get_sim(idx) pbs.barrier() if os.path.exists('/global'): lib_dir = '/global/cscratch1/sd/markm/lensit/temp/AN_sims_for_MCN1/%s_sims/fsky%04d/beam%d/res%s/%s/maps' % (nsims, fsky, Beam_FWHM_amin*10, LDres, exp) else: lib_dir = '/media/sf_C_DRIVE/Users/DarkMatter42/OneDrive - University of Sussex/LensIt/temp/AN_sims_for_MCN1/%s_sims/fsky%04d/beam%d/res%s/%s/maps' % (nsims, fsky, Beam_FWHM_amin*10, LDres, exp) return sims.ffs_maps.lib_noisefree(lib_dir, lib_datalm, len_cmbs, cl_transf, cache_sims=cache_maps)
def __init__(self, comm=None, signal_map="signal_map", lmax=None, grid=None, fwhm_deg=None, beam=None, out="smoothed_signal_map"): autotimer = timing.auto_timer(type(self).__name__) # We call the parent class constructor, which currently does nothing super().__init__() self.comm = comm self.signal_map = signal_map self.lmax = lmax self.out = out self.grid = grid # distribute alms local_m_indices = np.arange(self.comm.rank, lmax + 1, self.comm.size, dtype=np.int32) self.order = libsharp.packed_real_order(lmax, ms=local_m_indices) if (fwhm_deg is not None) and (beam is not None): raise Exception("OpSmooth error, specify either fwhm_deg or beam, " "not both") if (fwhm_deg is None) and (beam is None): raise Exception("OpSmooth error, specify fwhm_deg or beam") if fwhm_deg is not None: self.beam = hp.gauss_beam(fwhm=np.radians(fwhm_deg), lmax=lmax, pol=True) else: self.beam = beam
def cross_t(self, maps, wsp=None, fwhms=[None,None]): """ Cross PS, apply NaMaster estimator to T (scalar) map with(out) masks. Parameters ---------- maps : numpy.ndarray A two-row array array of two T maps. wsp : (PS-estimator-defined) workspace A template of mask-induced mode coupling matrix. fwhms : list, tuple FWHM of gaussian beams Returns ------- pseudo-PS results : tuple of numpy.ndarray (ell, TT, wsp(if input wsp is None)) """ assert isinstance(maps, np.ndarray) assert (maps.shape == (2,self._npix)) assert (len(fwhms) == 2) # assemble NaMaster fields if fwhms[0] is None: _f01 = nmt.NmtField(self._mask[0], [maps[0]]) else: _f01 = nmt.NmtField(self._mask[0], [maps[0]], beam=hp.gauss_beam(fwhms[0], 3*self._nside-1)) if fwhms[1] is None: _f02 = nmt.NmtField(self._mask[0], [maps[1]]) else: _f02 = nmt.NmtField(self._mask[0], [maps[1]], beam=hp.gauss_beam(fwhms[1], 3*self._nside-1)) # estimate PS if wsp is None: _w = nmt.NmtWorkspace() _w.compute_coupling_matrix(_f01, _f02, self._b) _cl00c = nmt.compute_coupled_cell(_f01, _f02) _cl00 = _w.decouple_cell(_cl00c) return (self._modes, _cl00[0], _w) else: _cl00c = nmt.compute_coupled_cell(_f01, _f02) _cl00 = wsp.decouple_cell(_cl00c) return (self._modes, _cl00[0])
def beamfunc1(self): if hasattr(self.beam1, '__iter__'): self._beamfunc1 = self.beam1 else: self._beamfunc1 = hp.gauss_beam(np.deg2rad(self.beam1), lmax=self.lmax - 1, pol=False) return self._beamfunc1
def _get_Cl_noise(instrument, A, lmax): bl = [ hp.gauss_beam(np.radians(b / 60.), lmax=lmax) for b in instrument.Beams ] nl = (np.array(bl) / np.radians(instrument.Sens_P / 60.)[:, np.newaxis])**2 AtNA = np.einsum('fi, fl, fj -> lij', A, nl, A) inv_AtNA = np.linalg.inv(AtNA) return inv_AtNA.swapaxes(-3, -1)
def test_gauss_beam(self): idl_gauss_beam = np.array( pf.open( os.path.join(self.path, "data", "gaussbeam_10arcmin_lmax512_pol.fits") )[0].data ).T gauss_beam = hp.gauss_beam(np.radians(10. / 60.), lmax=512, pol=True) np.testing.assert_allclose(idl_gauss_beam, gauss_beam)
def optimal_lmax(self, fwhm_in, nside_in): lmax = 2 * min(nside_in, self.nside) if fwhm_in < self.fwhm and self.quickpolbeam is None: beam = hp.gauss_beam(self.fwhm * arcmin, lmax=lmax, pol=False) better_lmax = np.argmin(np.abs(beam - 1e-4)) + 1 if better_lmax < lmax: lmax = better_lmax return lmax
def get_maps_lib(exp, LDres, HDres=14, cache_lenalms=True, cache_maps=False, \ nsims=120, num_threads=4, do_tensor_only=False, fn_tensCls=None): # end CH """ Default simulation library of 120 full flat sky sims for exp 'exp' at resolution LDres. Different exp at same resolution share the same random phases both in CMB and noise Will build all phases at the very first call if not already present. :param exp: 'Planck', 'S4' ... See get_config :param LDres: 14 : cell length is 0.745 amin, 13 : 1.49 etc. :return: sim library instance """ sN_uKamin, sN_uKaminP, Beam_FWHM_amin, ellmin, ellmax = get_config(exp) # Added by Chen Heinrich for Lensnet (2019/10) #len_cmbs = get_lencmbs_lib( # #res=HDres, cache_sims=cache_lenalms, nsims=nsims) if do_tensor_only == False: len_cmbs = get_lencmbs_lib( res=HDres, cache_sims=cache_lenalms, nsims=nsims) #CH19 else: len_cmbs = get_lencmbs_lib_tensor(fn_tensCls, res=HDres, cache_sims=cache_lenalms, nsims=nsims, \ num_threads=num_threads) #CH19 # end CH lmax_sky = len_cmbs.lib_skyalm.ellmax cl_transf = hp.gauss_beam( Beam_FWHM_amin / 60. * np.pi / 180., lmax=lmax_sky) lib_datalm = ffs_covs.ell_mat.ffs_alm_pyFFTW(get_ellmat(LDres, HDres), filt_func=lambda ell: ell <= lmax_sky, num_threads=num_threads) fsky = int( np.round(np.prod(len_cmbs.lib_skyalm.ell_mat.lsides) / 4. / np.pi * 1000.)) vcell_amin2 = np.prod(lib_datalm.ell_mat.lsides) / \ np.prod(lib_datalm.ell_mat.shape) * (180 * 60. / np.pi) ** 2 nTpix = sN_uKamin / np.sqrt(vcell_amin2) nPpix = sN_uKaminP / np.sqrt(vcell_amin2) pixpha = sims.ffs_phas.pix_lib_phas(LENSITDIR + '/temp/%s_sims/fsky%04d/res%s/pixpha' % (nsims, fsky, LDres), 3, lib_datalm.ell_mat.shape, nsims_max=nsims) if not pixpha.is_full() and pbs.rank == 0: for _i, idx in misc.misc_utils.enumerate_progress(np.arange(nsims), label='Generating Noise phases'): pixpha.get_sim(idx) pbs.barrier() # CH: takes care of different map location if maps are cached if fn_tensCls == None: cl_file_root = 'lensit_fiducial_tensCls' else: cl_file_root = os.path.splitext(os.path.basename(fn_tensCls))[0] if do_tensor_only == True: lib_dir = LENSITDIR + \ '/temp/%s/%s_sims/fsky%04d/res%s/%s/maps_tens' % (cl_file_root, nsims, fsky, LDres, exp) else: lib_dir = LENSITDIR + \ '/temp/%s_sims/fsky%04d/res%s/%s/maps' % (nsims, fsky, LDres, exp) print('get_maps_lib: maps lib_dir = %s'%lib_dir) return sims.ffs_maps.lib_noisemap(lib_dir, lib_datalm, len_cmbs, cl_transf, nTpix, nPpix, nPpix, pix_pha=pixpha, cache_sims=cache_maps)
def apodize(lib_datalm, mask, sigma_fwhm_armin=12., lmax=None, method='hybrid', mult_factor=3, min_factor=0.1): """ Flat sky apodizer directly adapted from Anthony curved sky libaml.apodize """ if sigma_fwhm_armin <= 0.: return mask lmax = lmax or lib_datalm.ell_mat.ellmax libalm = li.ffs_covs.ell_mat.ffs_alm_pyFFTW(lib_datalm.ell_mat, filt_func=lambda ell: ell <= lmax) print 'fsky_unapodized = %.5f' % (np.sum(mask ** 2) / mask.size) bl = hp.gauss_beam(sigma_fwhm_armin / 60. / 180. * np.pi, lmax=lmax) apomask = libalm.alm2map(libalm.almxfl(libalm.map2alm(mask), bl)) print 'Min/max mask smoothed mask', np.min(apomask), np.max(apomask) print 'fsky = %.5f' % (np.sum(apomask ** 2) / apomask.size) if method == 'gaussian': return apomask if method != 'hybrid': raise ValueError('Unknown apodization method') apomask = 1 - np.minimum(1., np.maximum(0., mult_factor * (1 - apomask) - min_factor)) bl = hp.gauss_beam(sigma_fwhm_armin * 0.5 / 60. / 180. * np.pi, lmax=lmax) apomask = libalm.alm2map(libalm.almxfl(libalm.map2alm(apomask), bl)) print 'Min/max mask re-smoothed mask', np.min(apomask), np.max(apomask) print 'fsky = %.5f' % (np.sum(apomask ** 2) / apomask.size) return apomask
def beamfunc1(self): if hasattr(self.beam1, '__iter__'): self._beamfunc1 = self.beam1 else: self._beamfunc1 = hp.gauss_beam( np.deg2rad(self.beam1), lmax=self.lmax-1, pol=False) return self._beamfunc1
def get_maps_lib(exp, LDres, HDres=14, cache_lenalms=True, cache_maps=False, nsims=120, num_threads=4): """ Default simulation library of 120 full flat sky sims for exp 'exp' at resolution LDres. Different exp at same resolution share the same random phases both in CMB and noise Will build all phases at the very first call if not already present. :param exp: 'Planck', 'S4' ... See get_config :param LDres: 14 : cell length is 0.745 amin, 13 : 1.49 etc. :return: sim library instance """ sN_uKamin, sN_uKaminP, Beam_FWHM_amin, ellmin, ellmax = get_config(exp) len_cmbs = get_lencmbs_lib(res=HDres, cache_sims=cache_lenalms, nsims=nsims) lmax_sky = len_cmbs.lib_skyalm.ellmax cl_transf = hp.gauss_beam(Beam_FWHM_amin / 60. * np.pi / 180., lmax=lmax_sky) lib_datalm = ffs_covs.ell_mat.ffs_alm_pyFFTW( get_ellmat(LDres, HDres), filt_func=lambda ell: ell <= lmax_sky, num_threads=num_threads) fsky = int( np.round( np.prod(len_cmbs.lib_skyalm.ell_mat.lsides) / 4. / np.pi * 1000.)) vcell_amin2 = np.prod(lib_datalm.ell_mat.lsides) / np.prod( lib_datalm.ell_mat.shape) * (180 * 60. / np.pi)**2 nTpix = sN_uKamin / np.sqrt(vcell_amin2) nPpix = sN_uKaminP / np.sqrt(vcell_amin2) pixpha = sims.ffs_phas.pix_lib_phas(LENSITDIR + '/temp/%s_sims/fsky%04d/res%s/pixpha' % (nsims, fsky, LDres), 3, lib_datalm.ell_mat.shape, nsims_max=nsims) if not pixpha.is_full() and pbs.rank == 0: for _i, idx in misc.misc_utils.enumerate_progress( np.arange(nsims), label='Generating Noise phases'): pixpha.get_sim(idx) pbs.barrier() lib_dir = LENSITDIR + '/temp/%s_sims/fsky%04d/res%s/%s/maps' % ( nsims, fsky, LDres, exp) return sims.ffs_maps.lib_noisemap(lib_dir, lib_datalm, len_cmbs, cl_transf, nTpix, nPpix, nPpix, pix_pha=pixpha, cache_sims=cache_maps)
def __mk_spectral_matrix_from_cl(self, cl=None): """ Here in grid units """ # TODO you may improve on that, in part. in respect to circulant embedding, zero mode etc.: Harmonize with others if cl is None: beam = gauss_beam(self.Beam_FWHM_amin * np.pi / 180. / 60., lmax=len(self.cl_unl) - 1) cl = self.cl_unl * beam ** 2 return np.interp(self.lib_cub.sqd_freqmap().flatten(), np.arange(len(cl))**2, cl * self.__nbar(),left =0.,right = 0.).reshape(self.shape)
def autoWSP_TT(self, maps, beams=None): # assemble NaMaster fields if beams is None: f0 = nmt.NmtField(self._apomask, [maps[0]]) else: f0 = nmt.NmtField(self._apomask, [maps[0]], beam=hp.gauss_beam(beams, 3*self._nside-1)) # prepare workspace w = nmt.NmtWorkspace() w.compute_coupling_matrix(f0, f0, self._b) return w
def crosBP_TT(self, maps, wsp=None, beams=[None,None]): dat1 = maps[0] dat2 = maps[3] # assemble NaMaster fields if beams[0] is None: f01 = nmt.NmtField(self._apomask, [dat1]) else: f01 = nmt.NmtField(self._apomask, [dat1], beam=hp.gauss_beam(beams[0], 3*self._nside-1)) if beams[1] is None: f02 = nmt.NmtField(self._apomask, [dat2]) else: f02 = nmt.NmtField(self._apomask, [dat2], beam=hp.gauss_beam(beams[1], 3*self._nside-1)) # estimate PS if wsp is None: cl00 = nmt.compute_full_master(f01, f02, self._b) return (self._modes, self.rebinning(cl00[0])) else: cl00c = nmt.compute_coupled_cell(f01, f02) cl00 = wsp.decouple_cell(cl00c) return (self._modes, self.rebinning(cl00[0]))
def _get_Cl_noise(instrument, A, lmax): try: bl = np.array([hp.gauss_beam(np.radians(b/60.), lmax=lmax) for b in instrument.fwhm]) except AttributeError: bl = np.ones((len(instrument.frequency), lmax+1)) nl = (bl / np.radians(instrument.depth_p/60.)[:, np.newaxis])**2 AtNA = np.einsum('fi, fl, fj -> lij', A, nl, A) inv_AtNA = np.linalg.inv(AtNA) return inv_AtNA.swapaxes(-3, -1)
def sensitivity_to_noise_mean_Cl(det_sens, beam_fwhm, lmax, t_mission=T_MISSION, n_det=N_DET_145, f_sky=1.0): """ Given the sensitivity of the instrument, observation time and number of detectors, and assuming that the scan was uniform, tis gives us the theoretical mean of the noise spectra for TT, EE, and BB. """ w_inv = sensitivity_to_noise_solid_angle(det_sens, t_mission, n_det)**2 Bl_squared = hp.gauss_beam(fwhm=beam_fwhm, lmax=lmax, pol=True)**2 noise_mean = np.empty((3, lmax+1)) for i in range(3): noise_mean[i] = np.sqrt(1.0/f_sky)*w_inv[i]/Bl_squared[...,i] noise_mean[i][:2] = 0.0 return noise_mean
def get_gaussian_beam(self, lmax=1024, pol=False, beam_eff=False): """Equivalent gaussian beam from RIMO FWHM Returns the transfer function of a gaussian beam until lmax, either polarized or not""" import healpy as hp beam = hp.gauss_beam(self.fwhm, lmax, pol) if beam_eff: beam *= self.beam_efficiency return beam
def cross_teb(self, maps, wsp=None, fwhms=[None,None]): assert isinstance(maps, np.ndarray) assert (maps.shape == (6,self._npix)) # assemble NaMaster fields if fwhms[0] is None: _f01 = nmt.NmtField(self._mask[0], [maps[0]]) _f21 = nmt.NmtField(self._mask[0], [maps[1], maps[2]], purify_e=False, purify_b=True) else: _f01 = nmt.NmtField(self._mask[0], [maps[0]], beam=hp.gauss_beam(fwhms[0], 3*self._nside-1)) _f21 = nmt.NmtField(self._mask[0], [maps[1], maps[2]], purify_e=False, purify_b=True, beam=hp.gauss_beam(fwhms[0], 3*self._nside-1)) if fwhms[1] is None: _f02 = nmt.NmtField(self._mask[0], [maps[3]]) _f22 = nmt.NmtField(self._mask[0], [maps[4], maps[5]], purify_e=False, purify_b=True) else: _f02 = nmt.NmtField(self._mask[0], [maps[3]], beam=hp.gauss_beam(fwhms[1], 3*self._nside-1)) _f22 = nmt.NmtField(self._mask[0], [maps[4], maps[5]], purify_e=False, purify_b=True, beam=hp.gauss_beam(fwhms[1], 3*self._nside-1)) # estimate PS _cl00 = nmt.compute_full_master(_f01, _f02, self._b) _cl02 = nmt.compute_full_master(_f01, _f22, self._b) _cl22 = nmt.compute_full_master(_f21, _f22, self._b) return (self._modes, _cl00[0], _cl02[0], _cl02[1], _cl22[0], _cl22[1], _cl22[3])
def set_signal_cov(self, cl, fwhm=None): """Set signal cov from Cls and assignt quantities to .signal_cov atribute""" if fwhm is not None: bl = hp.gauss_beam(fwhm, lmax=len(cl) - 1) self.signal_cov = sc.SignalCov(bl**2 * cl, self.params.lmax) else: self.signal_cov = sc.SignalCov(cl, self.params.lmax) try: self.set_delta() except: pass
def sensitivity_to_noise_variance_Cl(det_sens, beam_fwhm, lmax, t_mission=T_MISSION, n_det=N_DET_145, f_sky=1.0): """ Given the sensitivity of the instrument, observation time and number of detectors, and assuming that the scan was uniform, this gives us the theoretical variance of the noise spectra for TT, EE, and BB. """ w_inv = sensitivity_to_noise_solid_angle(det_sens, t_mission, n_det)**2 ell = np.arange(lmax + 1) Bl_squared = hp.gauss_beam(fwhm=beam_fwhm, lmax=lmax, pol=True)**2 variance = np.empty((3, lmax+1)) for i in range(3): variance[i] = (2.0/(2.0*ell + 1)/f_sky)*(w_inv[i]/Bl_squared[...,i])**2 variance[i][:2] = 0.0 return variance
def ini_field(mask, maps, fwhm, temp): '''Initialize pymaster field.''' if fwhm > 0: print('>> Computing Gaussian beam window function, FWHM = {0:f} [radians]' .format(fwhm)) lmax = 3 * hp.get_nside(mask) - 1 # required by PyMaster bl = hp.gauss_beam(fwhm, lmax=lmax, pol=False) else: bl = None print('>> Initializing the field...') fld = nmt.NmtField(mask, [maps], beam=bl, templates=temp) return fld
def deconvolve_cl(spectra, fwhm, lmax): if spectra.ndim == 1: pol = False else: pol = True Bl = hp.gauss_beam(fwhm=fwhm, lmax=lmax, pol=pol) if pol: spectra /= Bl.T**2 else: spectra /= Bl**2 return spectra
def fwhm(self, fwhm): if fwhm == 0.0: self._fwhm = fwhm bl=np.ones(3*self._qml_nside+1) l=np.arange(self._qml_nside+1,3*self._qml_nside+1) bl[self._qml_nside+1:3*self._qml_nside+1]=0.5*(1+np.sin(l*np.pi/2/self._qml_nside)) self._bell = bl else: self._fwhm = fwhm bl=np.ones(3*self._qml_nside+1) l=np.arange(self._qml_nside+1,3*self._qml_nside+1) bl[self._qml_nside+1:3*self._qml_nside+1]=0.5*(1+np.sin(l*np.pi/2/self._qml_nside)) self._bell = bl*hp.gauss_beam(np.deg2rad(self._fwhm), lmax=3*self._qml_nside)
def beamfunc2(self): # if self.beam2 is None and self._map2 is None: # self._beamfunc2 = self.beamfunc1 # return self._beamfunc2 if self.beam2 is None: self._beamfunc2 = np.ones(self.lmax, dtype=np.float32) elif hasattr(self.beam2, '__iter__'): self._beamfunc2 = self.beam2 else: self._beamfunc2 = hp.gauss_beam( np.deg2rad(self.beam2), lmax=self.lmax-1, pol=False) return self._beamfunc2
def estimate_cl(sky_map, lmax, binary_mask=None, fwhm=0.0, pol=True): sky_map_masked, binary_mask = mask_map(sky_map, binary_mask=binary_mask, pol=pol, ret_mask=True, fill_zeros=True) f_sky = float(np.sum(binary_mask))/binary_mask.size Bl = hp.gauss_beam(fwhm=fwhm, lmax=lmax, pol=pol) if pol: spectra = hp.anafast((sky_map_masked[0].filled(), sky_map_masked[1].filled(), sky_map_masked[2].filled()), lmax=lmax)[:4] spectra = np.array(spectra) spectra /= f_sky*Bl.T**2 else: spectra = hp.anafast(sky_map_masked.filled(), lmax=lmax) spectra /= f_sky*Bl**2 spectra = np.array(spectra) return spectra
def wiener_filter_for_alm(alm, lmax=None, fwhm=0.0, f_sky=1.0, sky_prior=None): if lmax is None: lmax = hp.Alm.getlmax(len(alm), None) if sky_prior is None: spectra_th = np.load("/global/homes/b/banerji/simulation/spectra/r_001/lensedtot_cls.npy")[0,:lmax+1] else: spectra_th = estimate_cl(sky_prior, lmax, fwhm=fwhm, pol=False) Bl = hp.gauss_beam(fwhm=fwhm, lmax=lmax, pol=False) spectra_ob = hp.alm2cl(alm, lmax_out=lmax) spectra_ob /= f_sky*Bl**2 filter_response = spectra_ob/spectra_th filter_response[:2] = 1.0 filter_response = np.sqrt(filter_response) return filter_response
def __init__(self, cl_unl, cl_len, LD_res, HD_res, lside, f, f_inv,sN_uKamin,Beam_FWHM_amin,verbose=False): """ f and finv are displacement field classes. Number of points on each side 2**LD_res,2**HD_res. f and f_inv must have a f.lens_map routine that does the lensing of map 2**HD_res by 2**HD_res. f_inv must also have a f.det_M routine which returns the determinant of the magnification matrix at all points of the map. """ self.LD_cub = library_datacube(np.ones(2, dtype=int) * LD_res, np.ones(2) * lside, verbose=verbose) self.HD_cub = library_datacube(np.ones(2, dtype=int) * HD_res, np.ones(2) * lside, verbose=verbose) self.LD_shape = self.LD_cub.shape() self.HD_shape = self.HD_cub.shape() self.f_inv = f_inv # inverse displacement self.f = f # displacement self.cl_unl = cl_unl self.cl_len = cl_len self.sN_uKamin = sN_uKamin self.Beam_FWHM_amin = Beam_FWHM_amin self.verbose = verbose # FIXME : the value of the variance jumps by a factor 5-6 if the l = 0 is interpolated ! # There is something fishy with the lowest mode. # Again circulant embedding is probably better, but how to get the fake spectra ? # Builds useful FFT maps. # All spectral maps in grid units ! (nbar * PhysicalSpectrum) # TODO Hack self.N_2p1 = 2**(HD_res -1) + 1 kmax_grid = np.sqrt(np.sum(self.HD_cub.kmax()**2)) self.HD_cl_unl_SpecMap = self._mk_HD_spectral_map_from_cl(cl_unl)[:,0:self.N_2p1] self.HD_Beam_SpecMap = self._mk_HD_spectral_map_from_cl( gauss_beam(Beam_FWHM_amin * np.pi / 180. / 60., lmax=kmax_grid+1)) self.HD_Beam_SpecMap *= square_pixwin_map(self.HD_shape) assert (np.all(self.HD_cl_unl_SpecMap >= 0.)), "Somethings wrong" assert (np.all(self.HD_Beam_SpecMap >= 0.)), "Somethings wrong"
def correlate_noise(i_file,j_file,wl_i,wl_j,alpha_file,bands,beam=False,gal_cut=0.,mask_file=None): print "Computing Noise Correlation for Bands "+str(bands) hdu_i=fits.open(i_file) hdu_j=fits.open(j_file) alpha_radio=hp.read_map(alpha_file,hdu='maps/phi') delta_alpha_radio=hp.read_map(alpha_file,hdu='uncertainty/phi') #iqu_band_i=hdu_i['stokes iqu'].data #iqu_band_j=hdu_j['stokes iqu'].data nside_i=hdu_i['stokes iqu'].header['nside'] nside_j=hdu_j['stokes iqu'].header['nside'] hdu_i.close() hdu_j.close() ind_i=np.argwhere( wl == wl_i)[0][0] ind_j=np.argwhere( wl == wl_j)[0][0] npix_i=hp.nside2npix(nside_i) npix_j=hp.nside2npix(nside_j) iqu_band_i=np.zeros((3,npix_i)) iqu_band_j=np.zeros((3,npix_j)) sigma_i=[noise_const_pol[ind_i]*np.random.normal(0,1,npix_i),noise_const_pol[ind_i]*np.random.normal(0,1,npix_i)] sigma_j=[noise_const_pol[ind_j]*np.random.normal(0,1,npix_j),noise_const_pol[ind_j]*np.random.normal(0,1,npix_j)] iqu_band_i[1]=np.copy(sigma_i[0]) iqu_band_i[2]=np.copy(sigma_i[1]) iqu_band_j[1]=np.copy(sigma_j[0]) iqu_band_j[2]=np.copy(sigma_j[1]) iqu_band_i=hp.smoothing(iqu_band_i,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_i])**2)*np.pi/(180.*60.),verbose=False) iqu_band_j=hp.smoothing(iqu_band_j,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_j])**2)*np.pi/(180.*60.),verbose=False) #alpha_radio=hp.smoothing(alpha_radio,fwhm=np.pi/180.,lmax=383) iqu_band_i=hp.ud_grade(iqu_band_i,nside_out=nside_out,order_in='ring') iqu_band_j=hp.ud_grade(iqu_band_j,nside_out=nside_out,order_in='ring') const=2.*(wl_i**2-wl_j**2) Delta_Q=(iqu_band_i[1]-iqu_band_j[1])/const Delta_U=(iqu_band_i[2]-iqu_band_j[2])/const alpha_u=alpha_radio*iqu_band_j[2] alpha_q=-alpha_radio*iqu_band_j[1] DQm=hp.ma(Delta_Q) DUm=hp.ma(Delta_U) aQm=hp.ma(alpha_q) aUm=hp.ma(alpha_u) Bl_factor=np.repeat(1.,3*nside_out) #ipdb.set_trace() if beam: Bl_factor=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1) pix_area=hp.nside2pixarea(nside_out) #ipdb.set_trace() mask_bool=np.repeat(False,npix_out) if gal_cut > 0: pix=np.arange(hp.nside2npix(nside_out)) x,y,z=hp.pix2vec(nside,pix,nest=0) mask_bool= np.abs(z)<= np.sin(gal_cut*np.pi/180.) #mask_bool1[np.where(np.sqrt(iqu_band_j[1]**2+iqu_band_j[2]**2)<.2e-6)]=True if not (mask_file is None): mask_hdu=fits.open(mask_file) mask=mask_hdu[1].data.field(0) mask_hdu.close() mask=hp.reorder(mask,n2r=1) mask=hp.ud_grade(mask,nside_out=128) mask_bool=~mask.astype(bool) fsky= 1. - np.sum(mask)/float(len(mask)) L=np.sqrt(fsky*4*np.pi) dl_eff=2*np.pi/L DQm.mask=mask_bool DUm.mask=mask_bool aQm.mask=mask_bool aUm.mask=mask_bool #ipdb.set_trace() cross1=hp.anafast(DQm,map2=aUm)/Bl_factor**2 cross2=hp.anafast(DUm,map2=aQm)/Bl_factor**2 #cross1=np.mean(cross1_array,axis=0) ##Average over all Cross Spectra #cross2=np.mean(cross2_array,axis=0) ##Average over all Cross Spectra #hp.write_cl('cl_'+bands+'_FR_noise_QxaU.fits',cross1) #hp.write_cl('cl_'+bands+'_FR_noise_UxaQ.fits',cross2) return (cross1,cross2)
def correlate_theory(i_file,j_file,wl_i,wl_j,alpha_file,bands_name,beam=False,gal_cut=0.,mask_file=None): print "Computing Cross Correlations for Bands "+str(bands_name) radio_file='/data/wmap/faraday_MW_realdata.fits' cl_file='/home/matt/wmap/simul_scalCls.fits.lens' hdu_i=fits.open(i_file) hdu_j=fits.open(j_file) #iqu_band_i=hdu_i['stokes iqu'].data #iqu_band_j=hdu_j['stokes iqu'].data nside_i=hdu_i['stokes iqu'].header['nside'] nside_j=hdu_j['stokes iqu'].header['nside'] hdu_i.close() hdu_j.close() ind_i=np.where( wl == wl_i)[0][0] ind_j=np.where( wl == wl_j)[0][0] cls=hp.read_cl(cl_file) simul_cmb=hp.sphtfunc.synfast(cls,max(nside_i,nside_j),fwhm=0.,new=1,pol=1); alpha_radio=hp.read_map(radio_file,hdu='maps/phi'); ##Generate CMB for file J alpha_radio=hp.ud_grade(alpha_radio,nside_out=nside_j,order_in='ring',order_out='ring') simul_cmb=hp.ud_grade(simul_cmb,nside_out=nside_j) tmp_cmb=rotate_tqu.rotate_tqu(simul_cmb,wl_j,alpha_radio); iqu_band_j=hp.smoothing(tmp_cmb,fwhm=np.sqrt((beam_fwhm[ind_j]*np.pi/(180.*60.))**2-hp.nside2pixarea(nside_i)),verbose=False) ##Generate CMB for file I alpha_radio=hp.ud_grade(alpha_radio,nside_out=nside_i,order_in='ring',order_out='ring') simul_cmb=hp.ud_grade(simul_cmb,nside_out=nside_i) tmp_cmb=rotate_tqu.rotate_tqu(simul_cmb,wl_i,alpha_radio); #ipdb.set_trace() iqu_band_i=hp.smoothing(tmp_cmb,fwhm=np.sqrt((beam_fwhm[ind_i]*np.pi/(180.*60.))**2-hp.nside2pixarea(nside_i)),verbose=False) alpha_radio=hp.read_map(alpha_file,hdu='maps/phi') iqu_band_i=hp.smoothing(iqu_band_i,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_i])**2)*np.pi/(180.*60.),verbose=False) iqu_band_j=hp.smoothing(iqu_band_j,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_j])**2)*np.pi/(180.*60.),verbose=False) #alpha_radio=hp.smoothing(alpha_radio,fwhm=np.pi/180.,lmax=383) iqu_band_i=hp.ud_grade(iqu_band_i,nside_out=nside_out,order_in='ring') iqu_band_j=hp.ud_grade(iqu_band_j,nside_out=nside_out,order_in='ring') const=2.*(wl_i**2-wl_j**2) Delta_Q=(iqu_band_i[1]-iqu_band_j[1])/const Delta_U=(iqu_band_i[2]-iqu_band_j[2])/const alpha_u=alpha_radio*iqu_band_j[2] alpha_q=-alpha_radio*iqu_band_j[1] DQm=hp.ma(Delta_Q) DUm=hp.ma(Delta_U) aQm=hp.ma(alpha_q) aUm=hp.ma(alpha_u) Bl_factor=np.repeat(1.,3*nside_out) #ipdb.set_trace() if beam: Bl_factor=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1) pix_area=hp.nside2pixarea(nside_out) #ipdb.set_trace() mask_bool=np.repeat(False,npix_out) if gal_cut > 0: pix=np.arange(hp.nside2npix(nside_out)) x,y,z=hp.pix2vec(nside,pix,nest=0) mask_bool= np.abs(z)<= np.sin(gal_cut*np.pi/180.) #mask_bool1[np.where(np.sqrt(iqu_band_j[1]**2+iqu_band_j[2]**2)<.2e-6)]=True if not (mask_file is None): mask_hdu=fits.open(mask_file) mask=mask_hdu[1].data.field(0) mask_hdu.close() mask=hp.reorder(mask,n2r=1) mask=hp.ud_grade(mask,nside_out=128) mask_bool=~mask.astype(bool) fsky= 1. - np.sum(mask)/float(len(mask)) L=np.sqrt(fsky*4*np.pi) dl_eff=2*np.pi/L DQm.mask=mask_bool DUm.mask=mask_bool aQm.mask=mask_bool aUm.mask=mask_bool cross1=hp.anafast(DQm,map2=aUm)/Bl_factor**2 cross2=hp.anafast(DUm,map2=aQm)/Bl_factor**2 #cross1=np.mean(cross1_array,axis=0) ##Average over all Cross Spectra #cross2=np.mean(cross2_array,axis=0) ##Average over all Cross Spectra return (cross1,cross2)
def plot_mc(): bins=[1,5,10,20,25,50] l=np.arange(3*nside_out) ll=l*(l+1)/(2.*np.pi) bls=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)**2 for num, mask_file in enumerate(mask_array): f=np.load('prism_simul_'+mask_name[num]+'.npz') theory1_array_in=f['the1_in'] theory2_array_in=f['the2_in'] cross1_array_in=f['c1_in'] cross2_array_in=f['c2_in'] noise1_array_in=f['n1_in'] noise2_array_in=f['n2_in'] Ndq_array_in=f['ndq_in'] Ndu_array_in=f['ndu_in'] Nau_array_in=f['nau_in'] Naq_array_in=f['naq_in'] mask_hdu=fits.open(mask_file) mask=mask_hdu[1].data.field(0) mask_hdu.close() mask=hp.reorder(mask,n2r=1) mask=hp.ud_grade(mask,nside_out=128) mask_bool=~mask.astype(bool) fsky= 1. - np.sum(mask)/float(len(mask)) L=np.sqrt(fsky*4*np.pi) dl_eff=2*np.pi/L theory1_array_in=np.array(theory1_array_in)/fsky theory2_array_in=np.array(theory2_array_in)/fsky cross1_array_in=np.array(cross1_array_in)/fsky cross2_array_in=np.array(cross2_array_in)/fsky 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 noise2_array_in=np.array(noise2_array_in)/fsky for b in bins: N_dq=np.mean(Ndq_array_in,axis=1) N_au=np.mean(Nau_array_in,axis=1) delta1_in=np.sqrt(2.*abs((np.mean(cross1_array_in,axis=1).T-np.mean(noise1_array_in,axis=1).T)**2+(np.mean(cross1_array_in,axis=1).T-np.mean(noise1_array_in,axis=1).T)/2.*(N_dq+N_au)+N_dq*N_au/2.).T/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky)) cosmic1_in=np.sqrt(2./((2.*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory1_array_in,axis=1)**2) N_du=np.mean(Ndu_array_in,axis=1) N_aq=np.mean(Naq_array_in,axis=1) delta2_in=np.sqrt(2.*abs((np.mean(cross2_array_in,axis=1).T-np.mean(noise2_array_in,axis=1).T)**2+(np.mean(cross2_array_in,axis=1).T-np.mean(noise2_array_in,axis=1).T)/2.*(N_dq+N_au)+N_dq*N_au/2.).T/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky)) cosmic2_in=np.sqrt(2./((2*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory2_array_in,axis=1)**2) cross1_array=[[],[],[]] cross2_array=[[],[],[]] Ndq_array=[[],[],[]] Ndu_array=[[],[],[]] Nau_array=[[],[],[]] Naq_array=[[],[],[]] noise1_array=[[],[],[]] noise2_array=[[],[],[]] theory1_array=[[],[],[]] theory2_array=[[],[],[]] cosmic1=[[],[],[]] cosmic2=[[],[],[]] delta1=[[],[],[]] delta2=[[],[],[]] plot_l=[] if( b != 1): for m in xrange(len(cross1_array_in)): for n in xrange(len(cross1_array_in[0])): tmp_t1=bin_llcl.bin_llcl(ll*theory1_array_in[m][n]/bls,b) tmp_t2=bin_llcl.bin_llcl(ll*theory2_array_in[m][n]/bls,b) tmp_c1=bin_llcl.bin_llcl(ll*cross1_array_in[m][n]/bls,b) tmp_c2=bin_llcl.bin_llcl(ll*cross2_array_in[m][n]/bls,b) tmp_n1=bin_llcl.bin_llcl(ll*noise1_array_in[m][n]/bls,b) tmp_n2=bin_llcl.bin_llcl(ll*noise2_array_in[m][n]/bls,b) theory1_array[m].append(tmp_t1['llcl']) theory2_array[m].append(tmp_t2['llcl']) cross1_array[m].append(tmp_c1['llcl']) cross2_array[m].append(tmp_c2['llcl']) noise1_array[m].append(tmp_n1['llcl']) noise2_array[m].append(tmp_n2['llcl']) if n == len(cross1_array_in[0])-1: plot_l=tmp_c1['l_out'] tmp_c1=bin_llcl.bin_llcl(ll*cosmic1_in[m]/bls,b) tmp_d1=bin_llcl.bin_llcl(ll*delta1_in[m]/bls,b) cosmic1[m]=tmp_c1['llcl'] delta1[m]=tmp_d1['llcl'] tmp_c2=bin_llcl.bin_llcl(ll*cosmic2_in[m]/bls,b) tmp_d2=bin_llcl.bin_llcl(ll*delta2_in[m]/bls,b) cosmic2[m]=tmp_c2['llcl'] delta2[m]=tmp_d2['llcl'] else: plot_l=l theory1_array=np.multiply(ll/bls,theory1_array_in) cross1_array=np.multiply(ll/bls,cross1_array_in) noise1_array=np.multiply(ll/bls,noise1_array_in) theory2_array=np.multiply(ll/bls,theory2_array_in) cross2_array=np.multiply(ll/bls,cross2_array_in) noise2_array=np.multiply(ll/bls,noise2_array_in) cosmic1=cosmic1_in*ll/bls cosmic2=cosmic2_in*ll/bls delta1=delta1_in*ll/bls delta2=delta2_in*ll/bls #noise1=np.mean(noise1_array,axis=1) #noise2=np.mean(noise2_array,axis=1) theory_array = np.add(theory1_array,theory2_array) theory=np.mean(theory_array,axis=1) dtheory=np.std(theory_array,axis=1,ddof=1) cross_array = np.add(np.subtract(cross1_array,noise1_array),np.subtract(cross2_array,noise2_array)) cross=np.mean(cross_array,axis=1) dcross=np.std(cross_array,axis=1,ddof=1) cosmic=np.sqrt(np.array(cosmic1)**2+np.array(cosmic2)**2) delta=np.sqrt(np.array(delta1)**2+np.array(delta2)**2) cross=np.average(cross,weights=1./dcross**2,axis=0) theory=np.average(theory,weights=1./dcross**2,axis=0) dtheory=np.average(dtheory,weights=1./dcross**2,axis=0) cosmic=np.average(cosmic,weights=1./dcross**2,axis=0) delta=np.average(delta,weights=1./dcross**2,axis=0) dcross=np.sqrt(np.average(dcross**2,weights=1./dcross**2,axis=0)) #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,'prism_FR_simulation',title='PRISM FR Correlator',theory=theory*1e12,dtheory=dtheory*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 : a_scales=np.linspace(-2,4,121) chi_array=[] for a in a_scales: chi_array.append(np.sum( (cross - a*theory)**2/(dcross)**2)) ind = np.argmin(chi_array) #likelihood=np.exp(np.multiply(-1./2.,chi_array))/np.sqrt(2*np.pi) likelihood=np.exp(np.multiply(-1./2.,chi_array))/np.sum(np.exp(np.multiply(-1./2.,chi_array))*.05) 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)) Sig1=np.sum(cross*(theory/dcross)**2)/np.sum((theory/dcross)**2) Noise1=np.std(np.sum(cross_array*(theory/dcross)**2,axis=1)/np.sum((theory/dcross)**2)) SNR=Sig/Noise SNR1=Sig1/Noise1 Sig2=np.sum(cross/(dcross**2))/np.sum(1./dcross**2) Noise2=np.sqrt(1./np.sum(1./dcross**2)) Sig3=np.sum(cross*(theory/dcross)**2)/np.sum((theory/dcross)**2) Noise3=np.sqrt(np.sum(theory**2)/np.sum(theory**2/dcross**2)) SNR2=Sig2/Noise2 SNR3=Sig3/Noise3 #ipdb.set_trace() fig,ax1=plt.subplots(1,1) ax1.plot(a_scales,likelihood,'k.') ax1.set_title('Faraday Rotation Correlator') ax1.set_xlabel('Likelihood scalar') ax1.set_ylabel('Likelihood of Correlation') fig.savefig('FR_Correlation_Likelihood.png',format='png') fig.savefig('FR_Correlation_Likelihood.eps',format='eps') #ipdb.set_trace() f=open('Maximum_likelihood.txt','w') f.write('Maximum Likelihood: {0:2.5f}% for scale factor {1:.2f} \n'.format(float(likelihood[ind]*100),float(a_scales[ind]))) f.write('Probability of scale factor =1: {0:2.5f}% \n \n'.format(float(likelihood[np.where(a_scales ==1)])*100)) f.write('Detection Levels using Standard Deviation \n') f.write('Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n'.format(SNR,Sig, Noise)) f.write('Weighted Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n \n'.format(SNR1,Sig1,Noise)) f.write('Detection using Theoretical Noise \n') f.write('Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n'.format(SNR2,Sig2, Noise2)) f.write('Weighted Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n'.format(SNR3,Sig3,Noise3)) f.close() #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() # likelihood=np.exp(-np.dot(np.dot((vector-mu).T,lin.inv(cov)),(vector-mu))/2. )/(np.sqrt(2*np.pi*lin.det(cov))) # 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(likelihood[0,0])) # f.close() #subprocess.call('mv Maximum_likelihood.txt gal_cut_{0:0>2d}/'.format(cut), shell=True) 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)
#ukdet=np.array([150.,150.,380.]) #ndet=np.array([288.,512.,512.]) #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))
def main(): ##Define Files used to make maps radio_file='/data/wmap/faraday_MW_realdata.fits' cl_file='/home/matt/wmap/simul_scalCls.fits.lens' output_prefix='/home/matt/Planck/data/faraday/simul_maps/' synchrotron_file='/data/Planck/COM_CompMap_SynchrotronPol-commander_0256_R2.00.fits' dust_file='/data/Planck/COM_CompMap_DustPol-commander_1024_R2.00.fits' gamma_dust=6.626e-34/(1.38e-23*21) ##Define Parameters used to simulate Planck Fields bands=np.array([30.,44.,70.,100.,143.,217.,353.]) #beam_fwhm=np.array([33.,24.,14.,10.,7.1,5.0,5.0]) #noise_const_temp=np.array([2.0,2.7,4.7,2.5,2.2,4.8,14.7])*2.7255e-6 #noise_const_pol=np.array([2.8,3.9,6.7,4.0,4.2,9.8,29.8])*2.7255e-6 #beam_fwhm=np.array([33.,24.,14.,10.,7.1,5.0,5.0]) beam_fwhm=np.array([32.29,27,13.21,9.67,7.26,4.96,4.93]) pix_area_array=np.array([np.repeat(hp.nside2pixarea(1024),3),np.repeat(hp.nise2pixarea(2048),4)]) pix_area_array=np.sqrt(pix_area_array)*60*180./np.pi #beam_fwhm=np.array([33.,24.,14.,10.,7.1,5.0,5.0]) #noise_const_temp=np.array([2.0,2.7,4.7,2.5,2.2,4.8,14.7])*2.7255e-6 #noise_const_pol=np.array([2.8,3.9,6.7,4.0,4.2,9.8,29.8])*2.7255e-6 noise_const_temp=np.array([2.5,2.7,3.5,1.29,.555,.78,2.56])/pix_area_array*60.e-6 noise_const_pol=np.array([3.5,4.0,5.0,1.96,1.17,1.75,7.31])/pix_area_array*60.e-6 krj_to_kcmb=np.array([1.0217,1.0517,np.mean([1.1360,1.1405,1.1348]), np.mean([1.3058,1.3057]),np.mean([1.6735,1.6727]),np.mean([3,2203,3.2336,3.2329,3.2161]),np.mean([14.261,14.106])])*1e-6 sync_factor=krj_to_kcmb*np.array([20.*(.408/x)**2 for x in bands]) dust_factor=krj_to_kcmb*np.array([163.e-6*(np.exp(gamma_dust*353e9)-1)/(np.exp(gamma_dust*x*1e9)-1)* (x/353)**2.54 for x in bands]) nside=2048 npix=hp.nside2npix(nside) pix_area=hp.nside2pixarea(nside) ##Reverse ordre of arrays to Simulate larger NSIDE maps first bands = bands[::-1] beam_fwhm= beam_fwhm[::-1] noise_const_temp = noise_const_temp[::-1] noise_const_pol = noise_const_pol[::-1] wl=np.array([299792458./(band*1e9) for band in bands]) num_wl=len(wl) tqu_array=[] sigma_array=[] LFI=False LFI_IND=np.where(bands == 70)[0][0] cls=hp.read_cl(cl_file) print 'Generating Map' simul_cmb=hp.sphtfunc.synfast(cls,nside,fwhm=0.,new=1,pol=1); alpha_radio=hp.read_map(radio_file,hdu='maps/phi'); alpha_radio=hp.ud_grade(alpha_radio,nside_out=nside,order_in='ring',order_out='ring') bl_40=hp.gauss_beam(40.*np.pi/(180.*60.),3*nside-1) hdu_sync=fits.open(synchrotron_file) sync_q=hdu_sync[1].data.field(0) sync_u=hdu_sync[1].data.field(1) sync_q=hp.reorder(sync_q,n2r=1) tmp_alm=hp.map2alm(sync_q) tmp_alm=hp.almxfl(tmp_alm,1./bl_40) sync_q=hp.alm2map(tmp_alm,nside) #sync_q=hp.smoothing(sync_q,fwhm=40.*np.pi/(180.*60.),verbose=False,invert=True) sync_q=hp.ud_grade(sync_q,nside_out=nside) sync_u=hp.reorder(sync_u,n2r=1) tmp_alm=hp.map2alm(sync_u) tmp_alm=hp.almxfl(tmp_alm,1./bl_40) sync_u=hp.alm2map(tmp_alm,nside) #sync_u=hp.smoothing(sync_u,fwhm=40.*np.pi/(180.*60.),verbose=False,invert=True) sync_u=hp.ud_grade(sync_u,nside_out=nside) hdu_sync.close() bl_10=hp.gauss_beam(10*np.pi/(180.*60.),3*nside-1) hdu_dust=fits.open(dust_file) dust_q=hdu_dust[1].data.field(0) dust_u=hdu_dust[1].data.field(1) hdu_dust.close() dust_q=hp.reorder(dust_q,n2r=1) tmp_alm=hp.map2alm(dust_q) tmp_alm=hp.almxfl(tmp_alm,1./bl_10) dust_q=hp.alm2map(tmp_alm,nside) #dust_q=hp.smoothing(dust_q,fwhm=10.0*np.pi/(180.*60.),verbose=False,invert=True) dust_q=hp.ud_grade(dust_q,nside) dust_u=hp.reorder(dust_u,n2r=1) tmp_alm=hp.map2alm(dust_u) tmp_alm=hp.almxfl(tmp_alm,1./bl_10) dust_u=hp.alm2map(tmp_alm,nside) #dust_q=hp.smoothing(dust_q,fwhm=10.0*np.pi/(180.*60.),verbose=False,invert=True) dust_u=hp.ud_grade(dust_u,nside) nside=2048 pix_area=hp.nside2pixarea(nside) prim=fits.PrimaryHDU() prim.header['COMMENT']="Simulated Planck Data with Polarization" prim.header['COMMENT']="Created using CAMB" #ipdb.set_trace() for i in range(num_wl): if LFI: nside=1024 npix=hp.nside2npix(1024) simul_cmb=hp.ud_grade(simul_cmb,nside) alpha_radio=hp.ud_grade(alpha_radio,nside) sync_q=hp.ud_grade(sync_q,nside) sync_u=hp.ud_grade(sync_u,nside) dust_q=hp.ud_grade(sync_q,nside) dust_u=hp.ud_grade(sync_u,nside) pix_area=hp.nside2pixarea(nside) tmp_cmb=rotate_tqu(simul_cmb,wl[i],alpha_radio); tmp_didqdu=np.array([np.random.normal(0,1,npix)*noise_const_temp[i], np.random.normal(0,1,npix)*noise_const_pol[i] , np.random.normal(0,1,npix)*noise_const_pol[i]]) tmp_tqu=np.copy(tmp_cmb) #Add Polarized Foreground emission tmp_tqu[1]+= np.copy( dust_factor[i]*dust_q+sync_factor[i]*sync_q ) tmp_tqu[2]+= np.copy( dust_factor[i]*dust_u+sync_factor[i]*sync_u ) # tmp_tqu[1]+= np.copy(sync_factor[i]*sync_q) # tmp_tqu[2]+= np.copy(sync_factor[i]*sync_u) tmp_tqu=hp.sphtfunc.smoothing(tmp_tqu,fwhm=beam_fwhm[i]*np.pi/(180.*60.),pol=1) #Add Noise After smooothing #tmp_tqu+=tmp_didqdu sig_hdu=fits.ImageHDU(tmp_tqu) sig_hdu.header['TFIELDS']=(len(tmp_tqu),'number of fields in each row') sig_hdu.header["TTYPE1"]=("STOKES I") sig_hdu.header["TTYPE2"]=("STOKES Q") sig_hdu.header["TTYPE3"]=("STOKES U") sig_hdu.header["TUNIT1"]=("K_{CMB} Thermodynamic", 'Physical Units of Map') sig_hdu.header["TUNIT2"]=("K_{CMB} Thermodynamic", 'Physical Units of Map') sig_hdu.header["TUNIT3"]=("K_{CMB} Thermodynamic", 'Physical Units of Map') sig_hdu.header["TFORM1"]='E' sig_hdu.header["TFORM2"]='E' sig_hdu.header["TFORM3"]='E' sig_hdu.header["EXTNAME"]="STOKES IQU" sig_hdu.header['POLAR']= 'T' sig_hdu.header['POLCCONV']=('COSMO','Coord. Convention for polarisation COSMO/IAU') sig_hdu.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") sig_hdu.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") sig_hdu.header["NSIDE"]=(nside,'Healpix Resolution paramter') sig_hdu.header['OBJECT']=('FULLSKY','Sky coverage, either FULLSKY or PARTIAL') sig_hdu.header['OBS_NPIX']=(npix,'Number of pixels observed') sig_hdu.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') sig_hdu.header["COORDSYS"]=('G','Pixelization coordinate system') err_hdu=fits.ImageHDU(tmp_didqdu) err_hdu.header['TFIELDS']=(len(tmp_didqdu),'number of fields in each row') err_hdu.header["TTYPE1"]=("UNCERTAINTY I") err_hdu.header["TTYPE2"]=("UNCERTAINTY Q") err_hdu.header["TTYPE3"]=("UNCERTAINTY U") err_hdu.header["TUNIT1"]=("K_{CMB} Thermodynamic", 'Physical Units of Map') err_hdu.header["TUNIT2"]=("K_{CMB} Thermodynamic", 'Physical Units of Map') err_hdu.header["TUNIT3"]=("K_{CMB} Thermodynamic", 'Physical Units of Map') err_hdu.header["TFORM1"]='E' err_hdu.header["TFORM2"]='E' err_hdu.header["TFORM3"]='E' err_hdu.header["EXTNAME"]="UNCERTAINTIES" err_hdu.header['POLAR']= 'T' err_hdu.header['POLCCONV']=('COSMO','Coord. Convention for polarisation COSMO/IAU') err_hdu.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") err_hdu.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") err_hdu.header["NSIDE"]=(nside,'Healpix Resolution paramter') err_hdu.header['OBJECT']=('FULLSKY','Sky coverage, either FULLSKY or PARTIAL') err_hdu.header['OBS_NPIX']=(npix,'Number of pixels observed') err_hdu.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') err_hdu.header["COORDSYS"]=('G','Pixelization coordinate system') # ipdb.set_trace() tblist=fits.HDUList([prim,sig_hdu,err_hdu]) tblist.writeto(output_prefix+'planck_simulated_{0:0>3.0f}.fits'.format(bands[i]),clobber=True) print "planck_simulated_{:0>3.0f}.fits".format(bands[i]) print "Nside = {:0>4d}".format(nside) if i+1 == LFI_IND: LFI=True
l,m = hp.Alm.getlm(lmax) n_lm = len(l) ell = np.arange(0,lmax+1) below_horizon = np.where(theta > np.pi/2.)[0] nu = np.linspace(100,200,num=203)*u.MHz # Define primary beam #A = np.exp(-np.power(theta,2)/(2.*0.1)) #A = np.exp(-np.power(theta,2)/(2.*0.1)) A = np.ones_like(theta) A[below_horizon] = 0. a_lm = hp.map2alm(A,lmax=lmax) Cl_A = hp.alm2cl(a_lm,lmax=lmax) Cl_G = hp.gauss_beam(np.radians(90.),lmax) A_nu = np.outer(A,np.ones_like(nu)) #apod = np.ones_like(theta) #apod = np.exp(-np.power(theta,2)/(2.*0.5)) #disc = hp.query_disc(nside,[0,0,1],np.radians(80.)) #apod[disc] = 0. #apod = 1-np.exp(-np.power(theta,2)/(2.*0.5)) #apod = #apod = np.power(np.sin(phi),2) # Define fringe bmag = 30. bvec = np.array([0,1,0])*bmag b = np.outer(bvec,np.ones(npix))*u.m s = np.array(hp.pix2vec(nside,ipix))
def faraday_correlate_quiet(i_file,j_file,wl_i,wl_j,alpha_file,bands,beam=False,polar_mask=False): print "Computing Cross Correlations for Bands "+str(bands) hdu_i=fits.open(i_file) hdu_j=fits.open(j_file) alpha_radio=hp.read_map(alpha_file,hdu='maps/phi') alpha_radio=hp.ud_grade(alpha_radio,1024) iqu_band_i=hdu_i['stokes iqu'].data iqu_band_j=hdu_j['stokes iqu'].data sigma_i=hdu_i['Q/U UNCERTAINTIES'].data sigma_j=hdu_j['Q/U UNCERTAINTIES'].data field_pixels=hdu_i['SQUARE PIXELS'].data q_fwhm=[27.3,11.7] noise_const=np.array([36./f for f in q_fwhm])*1e-6 npix=hp.nside2npix(1024) sigma_i=[noise_const[0]*np.random.normal(0,1,npix),noise_const[1]*np.random.normal(0,1,npix)] sigma_j=[noise_const[0]*np.random.normal(0,1,npix),noise_const[1]*np.random.normal(0,1,npix)] iqu_band_i[1]+=sigma_i[0] iqu_band_i[2]+=sigma_i[1] iqu_band_j[1]+=sigma_j[0] iqu_band_j[2]+=sigma_j[1] hdu_i.close() hdu_j.close() iqu_band_i=hp.smoothing(iqu_band_i,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(q_fwhm[0])**2)*np.pi/(180.*60.),lmax=383) iqu_band_j=hp.smoothing(iqu_band_j,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(q_fwhm[1])**2)*np.pi/(180.*60.),lmax=383) #alpha_radio=hp.smoothing(alpha_radio,fwhm=np.pi/180.,lmax=383) const=2.*(wl_i**2-wl_j**2) Delta_Q=(iqu_band_i[1]-iqu_band_j[1])/const Delta_U=(iqu_band_i[2]-iqu_band_j[2])/const alpha_u=alpha_radio*iqu_band_j[2] alpha_q=-alpha_radio*iqu_band_j[1] if polar_mask: P=np.sqrt(iqu_band_j[1]**2+iqu_band_j[2]**2) bad_pix=np.where( P < .2e-6) Delta_Q[bad_pix]=0 Delta_U[bad_pix]=0 alpha_u[bad_pix]=0 alpha_q[bad_pix]=0 cross1_array=[] cross2_array=[] cross3_array=[] L=15*(np.pi/180.) k=np.arange(1,np.round(500*(L/(2*np.pi)))) l=2*np.pi*k/L Bl_factor=np.repeat(1,len(k)) if beam: Bl_factor=hp.gauss_beam(np.pi/180.,383) for field1 in xrange(4): pix_cmb=field_pixels.field(field1) nx=np.sqrt(pix_cmb.shape[0]) flat_dq=np.reshape(Delta_Q[pix_cmb],(nx,nx)) flat_du=np.reshape(Delta_U[pix_cmb],(nx,nx)) flat_aq=np.reshape(alpha_q[pix_cmb],(nx,nx)) flat_au=np.reshape(alpha_u[pix_cmb],(nx,nx)) dq_alm=fft.fftshift(fft.fft2(flat_dq,shape=[450,450])) du_alm=fft.fftshift(fft.fft2(flat_du,shape=[450,450])) aq_alm=fft.fftshift(fft.fft2(flat_aq,shape=[450,450])) au_alm=fft.fftshift(fft.fft2(flat_au,shape=[450,450])) pw2d_qau=np.real(dq_alm*np.conjugate(au_alm)) pw2d_uaq=np.real(du_alm*np.conjugate(aq_alm)) pw1d_qau=radialProfile.azimuthalAverage(pw2d_qau) pw1d_uaq=radialProfile.azimuthalAverage(pw2d_uaq) tmp_cl1=pw1d_qau[k.astype(int)-1]*L**2 tmp_cl2=pw1d_uaq[k.astype(int)-1]*L**2 # index=np.where( (np.sqrt(x**2+y**2) <= k[num_k] +1) & ( np.sqrt(x**2 + y**2) >= k[num_k] -1) ) # tmp1= np.sum(pw2d_qau[index])/(np.pi*( (k[num_k]+1)**2 -(k[num_k]-1)**2 ) ) # tmp2= np.sum(pw2d_uaq[index])/(np.pi*( (k[num_k]+1)**2 -(k[num_k]-1)**2 ) ) # tmp_cl1[num_k]=L**2*tmp1 # tmp_cl2[num_k]=L**2*tmp2 cross1_array.append(tmp_cl1/Bl_factor) cross2_array.append(tmp_cl2/Bl_factor) cross1=np.mean(cross1_array,axis=0) ##Average over all Cross Spectra cross2=np.mean(cross2_array,axis=0) ##Average over all Cross Spectra hp.write_cl('cl_'+bands+'_FR_QxaU.fits',cross1) hp.write_cl('cl_'+bands+'_FR_UxaQ.fits',cross2) return (cross1,cross2)
def faraday_correlate_quiet(i_file,j_file,wl_i,wl_j,alpha_file,bands,beam=False): print "Computer Cross Correlations for Bands "+str(bands) temperature_file='/data/Planck/COM_CompMap_CMB-smica_2048.fits' planck_T=hp.read_map(temperature_file) planck_T*=1e-6 hdu_i=fits.open(i_file) hdu_j=fits.open(j_file) alpha_radio=hp.read_map(alpha_file,hdu='maps/phi') iqu_band_i=hdu_i['stokes iqu'].data iqu_band_j=hdu_j['stokes iqu'].data sigma_i=hdu_i['Q/U UNCERTAINTIES'].data sigma_j=hdu_j['Q/U UNCERTAINTIES'].data #mask_hdu=fits.open('/data/wmap/wmap_polarization_analysis_mask_r9_9yr_v5.fits') #mask=mask_hdu[1].data.field(0) #mask_hdu.close() #mask=hp.reorder(mask,n2r=1) #mask=hdu_i['mask'].data #mask=hp.ud_grade(mask,nside_out=128) #pix=np.where(mask != 0) #pix=np.array(pix).reshape(len(pix[0])) #pix_bad=np.where(mask == 0) field_pixels=hdu_i['FIELD PIXELS'].data iqu_band_i[1]+=sigma_i[0] iqu_band_i[2]+=sigma_i[1] iqu_band_j[1]+=sigma_j[0] iqu_band_j[2]+=sigma_j[1] hdu_i.close() hdu_j.close() iqu_band_i=hp.ud_grade(iqu_band_i,nside_out=128,order_in='ring') iqu_band_j=hp.ud_grade(iqu_band_j,nside_out=128,order_in='ring') planck_T=hp.ud_grade(planck_T,nside_out=128,order_in='ring') iqu_band_i=hp.smoothing(iqu_band_i,pol=1,fwhm=np.pi/180.,lmax=383) iqu_band_j=hp.smoothing(iqu_band_j,pol=1,fwhm=np.pi/180.,lmax=383) planck_T=hp.smoothing(planck_T,fwhm=np.pi/180.,lmax=383) #alpha_radio=hp.smoothing(alpha_radio,fwhm=np.pi/180.,lmax=383) P=np.sqrt(iqu_band_j[1]**2+iqu_band_j[2]**2) weights=np.repeat(1,len(P)) num,bins,junk=plt.hist(P,bins=40) index=np.argmax(num) weights[np.where(P <= bins[index+1]/2.)]=.75 weights[np.where(P <= bins[index+1]/4.)]=.5 weights[np.where(P <= bins[index+1]/8.)]=.25 const=2.*(wl_i**2-wl_j**2) Delta_Q=(iqu_band_i[1]-iqu_band_j[1])/const*weights Delta_U=(iqu_band_i[2]-iqu_band_j[2])/const*weights alpha_u=alpha_radio*iqu_band_j[2]*weights alpha_q=-alpha_radio*iqu_band_j[1]*weights DQm=hp.ma(Delta_Q) DUm=hp.ma(Delta_U) aQm=hp.ma(alpha_q) aUm=hp.ma(alpha_u) cross1_array=[] cross2_array=[] cross3_array=[] if beam: l=np.arange(3*128) Bl_60=np.exp(-l*(l+1)*((60.0*np.pi/(180.*60.)/(np.sqrt(8.0*np.log(2.))))**2)/2.) Bl_11=np.exp(-l*(l+1)*((11.7*np.pi/(180.*60.)/(np.sqrt(8.0*np.log(2.))))**2)/2.) Bl_27=np.exp(-l*(l+1)*((27.3*np.pi/(180.*60.)/(np.sqrt(8.0*np.log(2.))))**2)/2.) Bl_factor=Bl_60**2*Bl_11*Bl_27 else: Bl_factor=hp.gauss_beam(11.7*np.pi/(180.*60),lmax=383)*hp.gauss_beam(27.3*np.pi/(180.*60.),lmax=383) for field1 in xrange(4): mask_bool1=np.repeat(True,len(Delta_Q)) pix_cmb1=field_pixels.field(field1) pix_cmb1=pix_cmb1[np.nonzero(pix_cmb1)] ##Take Pixels From Field 1 tmp=np.zeros(hp.nside2npix(1024)) tmp[pix_cmb1]=1 tmp=hp.ud_grade(tmp,128) mask_bool1[np.nonzero(tmp)]=False # mask_bool1[np.where(P<.7e-6)]=True DQm.mask=mask_bool1 DUm.mask=mask_bool1 aQm.mask=mask_bool1 aUm.mask=mask_bool1 TE_map=np.array([planck_T*alpha_radio,Delta_Q,Delta_U]) TEm=hp.ma(TE_map) TEm[0].mask=mask_bool1 TEm[1].mask=mask_bool1 TEm[2].mask=mask_bool1 cross1_array.append(hp.anafast(DQm,map2=aUm)/Bl_factor) cross2_array.append(hp.anafast(DUm,map2=aQm)/Bl_factor) cross_tmp=hp.anafast(TEm,pol=1,nspec=4) cross3_array.append(cross_tmp[-1]/Bl_factor) cross1=np.mean(cross1_array,axis=0) ##Average over all Cross Spectra cross2=np.mean(cross2_array,axis=0) ##Average over all Cross Spectra cross3=np.mean(cross3_array,axis=0) ##Average over all Cross Spectra hp.write_cl('cl_'+bands+'_FR_QxaU.fits',cross1) hp.write_cl('cl_'+bands+'_FR_UxaQ.fits',cross2) hp.write_cl('cl_'+bands+'_FR_TE_cmb.fits',cross3) return (cross1,cross2,cross3)
def get_bl(beam_FWHM_amin,ell_max = 20000): """ Transfer function """ return hp.gauss_beam(beam_FWHM_amin * np.pi / 180. / 60., lmax= ell_max)
local_nl = order.local_size() print("rank", rank, "local_nl", local_nl, "mval", order.mval()) mpi_comm = MPI.COMM_WORLD if mpi else None # map2alm # maps in libsharp are 3D, 2nd dimension is IQU, 3rd is pixel alm_sharp_I = libsharp.analysis(grid, order, np.ascontiguousarray(local_map[0].reshape((1, 1, -1))), spin=0, comm=mpi_comm) alm_sharp_P = libsharp.analysis(grid, order, np.ascontiguousarray(local_map[1:].reshape((1, 2, -1))), spin=2, comm=mpi_comm) beam = hp.gauss_beam(fwhm=np.radians(fwhm_deg), lmax=lmax, pol=True) print("Smooth") # smooth in place (zonca implemented this function) order.almxfl(alm_sharp_I, np.ascontiguousarray(beam[:, 0:1])) order.almxfl(alm_sharp_P, np.ascontiguousarray(beam[:, (1, 2)])) # alm2map new_local_map_I = libsharp.synthesis(grid, order, alm_sharp_I, spin=0, comm=mpi_comm) new_local_map_P = libsharp.synthesis(grid, order, alm_sharp_P, spin=2, comm=mpi_comm) # Transfer map to first process for writing local_full_map = np.zeros(input_map.shape, dtype=np.float64) local_full_map[0, local_pix] = new_local_map_I
hp.mollview(radio_map, norm='hist', unit='$K_{CMB}$') plt.savefig('mwa_1hr_raw.png', format='png') plt.close() cross_cls = hp.anafast(cmb_map,radio_fr) radio_cls = hp.anafast(radio_fr) cmb_cls = hp.anafast(cmb_map) lmax = len(cross_cls) beam_lmax = lmax l = np.arange(2,beam_lmax) ll = l*(l+1)/(2*np.pi) beam_3 = hp.gauss_beam(3.*np.pi/(180.*60.),beam_lmax-1)[2:] beam_5 = hp.gauss_beam(5.*np.pi/(180.*60.),beam_lmax-1)[2:] pix = hp.pixwin(256)[2:beam_lmax] theory_cls= hp.read_cl(theory_cl_file) theory_cls=theory_cls[0][2:beam_lmax] #theory_cls[:2]=1e-10 cross_cls = cross_cls[2:beam_lmax] radio_cls = radio_cls[2:beam_lmax] cmb_cls = cmb_cls[2: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) fsky = 1. - np.sum(mask_bool).astype(float)/len(mask_bool)
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 faraday_theory_quiet(i_file,j_file,wl_i,wl_j,alpha_file,bands_name,beam=False,polar_mask=False): print "Computing Cross Correlations for Bands "+str(bands_name) # radio_file='/data/wmap/faraday_MW_realdata.fits' # cl_file='/home/matt/wmap/simul_scalCls.fits' # nside=1024 # npix=hp.nside2npix(nside) # # cls=hp.read_cl(cl_file) # simul_cmb=hp.sphtfunc.synfast(cls,nside,fwhm=0.,new=1,pol=1); # # alpha_radio=hp.read_map(radio_file,hdu='maps/phi'); # alpha_radio=hp.ud_grade(alpha_radio,nside_out=nside,order_in='ring',order_out='ring') # bands=[43.1,94.5] q_fwhm=[27.3,11.7] # wl=np.array([299792458./(band*1e9) for band in bands]) # num_wl=len(wl) # t_array=np.zeros((num_wl,npix)) # q_array=np.zeros((num_wl,npix)) # u_array=np.zeros((num_wl,npix)) # for i in range(num_wl): # tmp_cmb=rotate_tqu.rotate_tqu(simul_cmb,wl[i],alpha_radio); # t_array[i],q_array[i],u_array[i]=tmp_cmb # iqu_band_i=[t_array[0],q_array[0],u_array[0]] # iqu_band_j=[t_array[1],q_array[1],u_array[1]] hdu_i=fits.open(i_file) hdu_j=fits.open(j_file) alpha_radio=hp.read_map(alpha_file,hdu='maps/phi') alpha_radio=hp.ud_grade(alpha_radio,1024) iqu_band_i=hdu_i['stokes iqu'].data iqu_band_j=hdu_j['stokes iqu'].data field_pixels=hdu_i['SQUARE PIXELS'].data hdu_i.close() hdu_j.close() iqu_band_i=hp.smoothing(iqu_band_i,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(q_fwhm[0])**2)*np.pi/(180.*60.),lmax=383) iqu_band_j=hp.smoothing(iqu_band_j,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(q_fwhm[1])**2)*np.pi/(180.*60.),lmax=383) #alpha_radio=hp.smoothing(alpha_radio,fwhm=np.pi/180.,lmax=383) const=2.*(wl_i**2-wl_j**2) Delta_Q=(iqu_band_i[1]-iqu_band_j[1])/const Delta_U=(iqu_band_i[2]-iqu_band_j[2])/const alpha_u=alpha_radio*iqu_band_j[2] alpha_q=-alpha_radio*iqu_band_j[1] if polar_mask: P=np.sqrt(iqu_band_j[1]**2+iqu_band_j[2]**2) bad_pix=np.where( P < .2e-6) Delta_Q[bad_pix]=0 Delta_U[bad_pix]=0 alpha_u[bad_pix]=0 alpha_q[bad_pix]=0 cross1_array=[] cross2_array=[] L=15*(np.pi/180.) k=np.arange(1,np.round(500*(L/(2*np.pi)))) l=2*np.pi*k/L Bl_factor=np.repeat(1,len(k)) if beam: Bl_factor=hp.gauss_beam(np.pi/180.,383) for field1 in xrange(4): pix_cmb=field_pixels.field(field1) nx=np.sqrt(pix_cmb.shape[0]) flat_dq=np.reshape(Delta_Q[pix_cmb],(nx,nx)) flat_du=np.reshape(Delta_U[pix_cmb],(nx,nx)) flat_aq=np.reshape(alpha_q[pix_cmb],(nx,nx)) flat_au=np.reshape(alpha_u[pix_cmb],(nx,nx)) dq_alm=fft.fftshift(fft.fft2(flat_dq,shape=[450,450])) du_alm=fft.fftshift(fft.fft2(flat_du,shape=[450,450])) aq_alm=fft.fftshift(fft.fft2(flat_aq,shape=[450,450])) au_alm=fft.fftshift(fft.fft2(flat_au,shape=[450,450])) pw2d_qau=np.real(dq_alm*np.conjugate(au_alm)) pw2d_uaq=np.real(du_alm*np.conjugate(aq_alm)) pw1d_qau=radialProfile.azimuthalAverage(pw2d_qau) pw1d_uaq=radialProfile.azimuthalAverage(pw2d_uaq) tmp_cl1=pw1d_qau[k.astype(int)-1]*L**2 tmp_cl2=pw1d_uaq[k.astype(int)-1]*L**2 # index=np.where( (np.sqrt(x**2+y**2) <= k[num_k] +1) & ( np.sqrt(x**2 + y**2) >= k[num_k] -1) ) # tmp1= np.sum(pw2d_qau[index])/(np.pi*( (k[num_k]+1)**2 -(k[num_k]-1)**2 ) ) # tmp2= np.sum(pw2d_uaq[index])/(np.pi*( (k[num_k]+1)**2 -(k[num_k]-1)**2 ) ) # tmp_cl1[num_k]=L**2*tmp1 # tmp_cl2[num_k]=L**2*tmp2 cross1_array.append(tmp_cl1/Bl_factor) cross2_array.append(tmp_cl2/Bl_factor) cross1=np.mean(cross1_array,axis=0) ##Average over all Cross Spectra cross2=np.mean(cross2_array,axis=0) ##Average over all Cross Spectra hp.write_cl('cl_'+bands_name+'_FR_QxaU.fits',cross1) hp.write_cl('cl_'+bands_name+'_FR_UxaQ.fits',cross2) return (cross1,cross2)
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)
hp.mollview(radio_map, norm='hist', unit='$K_{CMB}$') plt.savefig('chipass_raw.png', format='png') plt.close() cross_cls = hp.anafast(cmb_map,radio_fr) radio_cls = hp.anafast(radio_fr) cmb_cls = hp.anafast(cmb_map) 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]
def main(): ##Parameters for Binning, Number of Runs ## Beam correction use_beam=0 N_runs=100 bins=[1,5,10,20,25,50] gal_cut=[00,05,10,20,30] bls=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1)**2 l=np.arange(3*nside_out) ll=l*(l+1)/(2*np.pi) map_prefix='/home/matt/Planck/data/faraday/simul_maps/' file_prefix=map_prefix+'prism_simulated_' alpha_file='/data/wmap/faraday_MW_realdata.fits' #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() for num, mask_file in enumerate(mask_array): print(Fore.WHITE+Back.RED+Style.BRIGHT+'Mask: '+mask_name[num]+Back.RESET+Fore.RESET+Style.RESET_ALL) count=0 for i in [0,1,2]: for j in [3,4,5]: #for n in xrange(N_runs): for run in xrange(N_runs): print(Fore.WHITE+Back.GREEN+Style.BRIGHT+'Correlation #{:03d}'.format(run+1)+Back.RESET+Fore.RESET+Style.RESET_ALL) print('Bands: {0:0>3.0f} and {1:0>3.0f}'.format(bands[i],bands[j])) ttmp1,ttmp2=correlate_theory(file_prefix+'{0:0>3.0f}.fits'.format(bands[i]),file_prefix+'{0:0>3.0f}.fits'.format(bands[j]),wl[i],wl[j],alpha_file,'{0:0>3.0f}x{1:0>3.0f}'.format(bands[i],bands[j]),beam=use_beam,mask_file=mask_file) #f=open('cl_noise_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_UxaQ.json'.format(bands[i],bands[j],cut),'w') theory1_array_in[count].append(ttmp1) theory2_array_in[count].append(ttmp2) tmp1,tmp2,n1,n2,n3,n4=correlate_signal(file_prefix+'{0:0>3.0f}.fits'.format(bands[i]),file_prefix+'{0:0>3.0f}.fits'.format(bands[j]),wl[i],wl[j],alpha_file,'{0:0>3.0f}x{1:0>3.0f}'.format(bands[i],bands[j]),beam=use_beam,mask_file=mask_file) ntmp1,ntmp2=correlate_noise(file_prefix+'{0:0>3.0f}.fits'.format(bands[i]),file_prefix+'{0:0>3.0f}.fits'.format(bands[j]),wl[i],wl[j],alpha_file,'{0:0>3.0f}x{1:0>3.0f}'.format(bands[i],bands[j]),beam=use_beam,mask_file=mask_file) cross1_array_in[count].append(tmp1) cross2_array_in[count].append(tmp2) Ndq_array_in[count].append(n1) Ndu_array_in[count].append(n2) Nau_array_in[count].append(n3) Naq_array_in[count].append(n4) noise1_array_in[count].append(ntmp1) noise2_array_in[count].append(ntmp2) count+=1 np.savez('prism_simul_'+mask_name[num]+'.npz',the1_in=theory1_array_in,the2_in=theory2_array_in,c1_in=cross1_array_in,c2_in=cross2_array_in,ndq_in=Ndq_array_in,ndu_in=Ndu_array_in,nau_in=Nau_array_in,naq_in=Naq_array_in,n1_in=noise1_array_in,n2_in=noise2_array_in) #f=open('cl_theory_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_QxaU.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(theory1_array_in).tolist(),f) #f.close() #f=open('cl_theory_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_UxaQ.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(theory2_array_in).tolist(),f) #f.close() #f=open('cl_array_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_QxaU.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(cross1_array_in).tolist(),f) #f.close() #f=open('cl_array_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_UxaQ.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(cross2_array_in).tolist(),f) #f.close() #f=open('cl_noise_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_QxaU.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(noise1_array_in).tolist(),f) #f.close() #json.dump(np.array(noise2_array_in).tolist(),f) #f.close() #f=open('cl_Nau_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_QxaU.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(Nau_array_in).tolist(),f) #f.close() #f=open('cl_Ndq_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_QxaU.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(Ndq_array_in).tolist(),f) #f.close() #f=open('cl_Naq_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_UxaQ.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(Naq_array_in).tolist(),f) #f.close() #f=open('cl_Ndu_FR_{0:0>3.0f}x{1:0>3.0f}_cut{2:0>2d}_UxaQ.json'.format(bands[i],bands[j],cut),'w') #json.dump(np.array(Ndu_array_in).tolist(),f) #f.close() #fsky= 1. - np.sin(cut*np.pi/180.) #L=np.sqrt(fsky*4*np.pi) #dl_eff=2*np.pi/L mask_hdu=fits.open(mask_file) mask=mask_hdu[1].data.field(0) mask_hdu.close() mask=hp.reorder(mask,n2r=1) mask=hp.ud_grade(mask,nside_out=128) mask_bool=~mask.astype(bool) fsky= 1. - np.sum(mask)/float(len(mask)) L=np.sqrt(fsky*4*np.pi) dl_eff=2*np.pi/L theory1_array_in=np.array(theory1_array_in)/fsky theory2_array_in=np.array(theory2_array_in)/fsky cross1_array_in=np.array(cross1_array_in)/fsky cross2_array_in=np.array(cross2_array_in)/fsky 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 noise2_array_in=np.array(noise2_array_in)/fsky for b in bins: N_dq=np.mean(Ndq_array_in,axis=1) N_au=np.mean(Nau_array_in,axis=1) delta1_in=np.sqrt(2.*abs((np.mean(cross1_array_in,axis=1).T-np.mean(noise1_array_in,axis=1).T)**2+(np.mean(cross1_array_in,axis=1).T-np.mean(noise1_array_in,axis=1).T)/2.*(N_dq+N_au)+N_dq*N_au/2.).T/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky)) cosmic1_in=np.sqrt(2./((2.*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory1_array_in,axis=1)**2) N_du=np.mean(Ndu_array_in,axis=1) N_aq=np.mean(Naq_array_in,axis=1) delta2_in=np.sqrt(2.*abs((np.mean(cross2_array_in,axis=1).T-np.mean(noise2_array_in,axis=1).T)**2+(np.mean(cross2_array_in,axis=1).T-np.mean(noise2_array_in,axis=1).T)/2.*(N_dq+N_au)+N_dq*N_au/2.).T/((2.*l+1.)*np.sqrt(b**2+dl_eff**2)*fsky)) cosmic2_in=np.sqrt(2./((2*l+1)*np.sqrt(b**2+dl_eff**2)*fsky)*np.mean(theory2_array_in,axis=1)**2) cross1_array=[[],[],[]] cross2_array=[[],[],[]] Ndq_array=[[],[],[]] Ndu_array=[[],[],[]] Nau_array=[[],[],[]] Naq_array=[[],[],[]] noise1_array=[[],[],[]] noise2_array=[[],[],[]] theory1_array=[[],[],[]] theory2_array=[[],[],[]] cosmic1=[[],[],[]] cosmic2=[[],[],[]] delta1=[[],[],[]] delta2=[[],[],[]] plot_l=[] if( b != 1): for m in xrange(len(cross1_array_in)): for n in xrange(len(cross1_array_in[0])): tmp_t1=bin_llcl.bin_llcl(ll*theory1_array_in[m][n]/bls,b) tmp_t2=bin_llcl.bin_llcl(ll*theory2_array_in[m][n]/bls,b) tmp_c1=bin_llcl.bin_llcl(ll*cross1_array_in[m][n]/bls,b) tmp_c2=bin_llcl.bin_llcl(ll*cross2_array_in[m][n]/bls,b) tmp_n1=bin_llcl.bin_llcl(ll*noise1_array_in[m][n]/bls,b) tmp_n2=bin_llcl.bin_llcl(ll*noise2_array_in[m][n]/bls,b) theory1_array[m].append(tmp_t1['llcl']) theory2_array[m].append(tmp_t2['llcl']) cross1_array[m].append(tmp_c1['llcl']) cross2_array[m].append(tmp_c2['llcl']) noise1_array[m].append(tmp_n1['llcl']) noise2_array[m].append(tmp_n2['llcl']) if n == len(cross1_array_in[0])-1: plot_l=tmp_c1['l_out'] tmp_c1=bin_llcl.bin_llcl(ll*cosmic1_in[m]/bls,b) tmp_d1=bin_llcl.bin_llcl(ll*delta1_in[m]/bls,b) cosmic1[m]=tmp_c1['llcl'] delta1[m]=tmp_d1['llcl'] tmp_c2=bin_llcl.bin_llcl(ll*cosmic2_in[m]/bls,b) tmp_d2=bin_llcl.bin_llcl(ll*delta2_in[m]/bls,b) cosmic2[m]=tmp_c2['llcl'] delta2[m]=tmp_d2['llcl'] else: plot_l=l theory1_array=np.multiply(ll/bls,theory1_array_in) cross1_array=np.multiply(ll/bls,cross1_array_in) noise1_array=np.multiply(ll/bls,noise1_array_in) theory2_array=np.multiply(ll/bls,theory2_array_in) cross2_array=np.multiply(ll/bls,cross2_array_in) noise2_array=np.multiply(ll/bls,noise2_array_in) cosmic1=cosmic1_in*ll/bls cosmic2=cosmic2_in*ll/bls delta1=delta1_in*ll/bls delta2=delta2_in*ll/bls #noise1=np.mean(noise1_array,axis=1) #noise2=np.mean(noise2_array,axis=1) theory_array = np.add(theory1_array,theory2_array) theory=np.mean(theory_array,axis=1) dtheory=np.std(theory_array,axis=1,ddof=1) cross_array = np.add(np.subtract(cross1_array,noise1_array),np.subtract(cross2_array,noise2_array)) cross=np.mean(cross_array,axis=1) dcross=np.std(cross_array,axis=1,ddof=1) cosmic=np.sqrt(np.array(cosmic1)**2+np.array(cosmic2)**2) delta=np.sqrt(np.array(delta1)**2+np.array(delta2)**2) cross=np.average(cross,weights=1./dcross**2,axis=0) theory=np.average(theory,weights=1./dcross**2,axis=0) dtheory=np.average(dtheory,weights=1./dcross**2,axis=0) cosmic=np.average(cosmic,weights=1./dcross**2,axis=0) delta=np.average(delta,weights=1./dcross**2,axis=0) dcross=np.sqrt(np.average(dcross**2,weights=1./dcross**2,axis=0)) #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,'prism_FR_simulation',title='PRISM FR Correlator',theory=theory*1e12,dtheory=dtheory*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 : a_scales=np.linspace(-2,4,121) chi_array=[] for a in a_scales: chi_array.append(np.sum( (cross - a*theory)**2/(dcross)**2)) ind = np.argmin(chi_array) #likelihood=np.exp(np.multiply(-1./2.,chi_array))/np.sqrt(2*np.pi) likelihood=np.exp(np.multiply(-1./2.,chi_array))/np.sum(np.exp(np.multiply(-1./2.,chi_array))*.05) 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)) Sig1=np.sum(cross*(theory/dcross)**2)/np.sum((theory/dcross)**2) Noise1=np.std(np.sum(cross_array*(theory/dcross)**2,axis=1)/np.sum((theory/dcross)**2)) SNR=Sig/Noise SNR1=Sig1/Noise1 Sig2=np.sum(cross/(dcross**2))/np.sum(1./dcross**2) Noise2=np.sqrt(1./np.sum(1./dcross**2)) Sig3=np.sum(cross*(theory/dcross)**2)/np.sum((theory/dcross)**2) Noise3=np.sqrt(np.sum(theory**2)/np.sum(theory**2/dcross**2)) SNR2=Sig2/Noise2 SNR3=Sig3/Noise3 #ipdb.set_trace() fig,ax1=plt.subplots(1,1) ax1.plot(a_scales,likelihood,'k.') ax1.set_title('Faraday Rotation Correlator') ax1.set_xlabel('Likelihood scalar') ax1.set_ylabel('Likelihood of Correlation') fig.savefig('FR_Correlation_Likelihood.png',format='png') fig.savefig('FR_Correlation_Likelihood.eps',format='eps') #ipdb.set_trace() f=open('Maximum_likelihood.txt','w') f.write('Maximum Likelihood: {0:2.5f}% for scale factor {1:.2f} \n'.format(float(likelihood[ind]*100),float(a_scales[ind]))) f.write('Probability of scale factor =1: {0:2.5f}% \n \n'.format(float(likelihood[np.where(a_scales ==1)])*100)) f.write('Detection Levels using Standard Deviation \n') f.write('Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n'.format(SNR,Sig, Noise)) f.write('Weighted Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n \n'.format(SNR1,Sig1,Noise)) f.write('Detection using Theoretical Noise \n') f.write('Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n'.format(SNR2,Sig2, Noise2)) f.write('Weighted Detection Level: {0:.4f} sigma, Signal= {1:.4e}, Noise= {2:.4e} \n'.format(SNR3,Sig3,Noise3)) f.close() #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() # likelihood=np.exp(-np.dot(np.dot((vector-mu).T,lin.inv(cov)),(vector-mu))/2. )/(np.sqrt(2*np.pi*lin.det(cov))) # 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(likelihood[0,0])) # f.close() #subprocess.call('mv Maximum_likelihood.txt gal_cut_{0:0>2d}/'.format(cut), shell=True) 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 beam_cl(self): return gauss_beam(self.beam_FWHM_amin * np.pi / 180. / 60., lmax=self.lmax_grid())
def correlate_signal(i_file,j_file,wl_i,wl_j,alpha_file,bands,beam=False,gal_cut=0.,mask_file=None): print "Computing Cross Correlations for Bands "+str(bands) hdu_i=fits.open(i_file) hdu_j=fits.open(j_file) alpha_radio=hp.read_map(alpha_file,hdu='maps/phi') delta_alpha_radio=hp.read_map(alpha_file,hdu='uncertainty/phi') iqu_band_i=hdu_i['stokes iqu'].data iqu_band_j=hdu_j['stokes iqu'].data nside_i=hdu_i['stokes iqu'].header['nside'] nside_j=hdu_j['stokes iqu'].header['nside'] hdu_i.close() hdu_j.close() ind_i=np.argwhere( wl == wl_i)[0][0] ind_j=np.argwhere( wl == wl_j)[0][0] npix_i=hp.nside2npix(nside_i) npix_j=hp.nside2npix(nside_j) #ipdb.set_trace() if npix_i != iqu_band_i[1].shape[0]: print 'NSIDE parameter not equal to size of map for file I' print 'setting npix to larger parameter' npix_i=iqu_band_i[1].shape[0] if npix_j != iqu_band_j[1].shape[0]: print 'NSIDE parameter not equal to size of map for file J' print 'setting npix to larger parameter' npix_j=iqu_band_j[1].shape[0] sigma_i=[noise_const_pol[ind_i]*np.random.normal(0,1,npix_i),noise_const_pol[ind_i]*np.random.normal(0,1,npix_i)] sigma_j=[noise_const_pol[ind_j]*np.random.normal(0,1,npix_j),noise_const_pol[ind_j]*np.random.normal(0,1,npix_j)] iqu_band_i[1]+=sigma_i[0] iqu_band_i[2]+=sigma_i[1] iqu_band_j[1]+=sigma_j[0] iqu_band_j[2]+=sigma_j[1] sigma_q_i=hp.smoothing(sigma_i[0],fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_i])**2)*np.pi/(180.*60.),verbose=False) sigma_u_i=hp.smoothing(sigma_i[1],fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_i])**2)*np.pi/(180.*60.),verbose=False) sigma_q_j=hp.smoothing(sigma_j[0],fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_j])**2)*np.pi/(180.*60.),verbose=False) sigma_u_j=hp.smoothing(sigma_j[1],fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_j])**2)*np.pi/(180.*60.),verbose=False) sigma_q_i=hp.ud_grade(sigma_q_i,nside_out) sigma_u_i=hp.ud_grade(sigma_u_i,nside_out) sigma_q_j=hp.ud_grade(sigma_q_j,nside_out) sigma_u_j=hp.ud_grade(sigma_u_j,nside_out) iqu_band_i=hp.smoothing(iqu_band_i,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_i])**2)*np.pi/(180.*60.),verbose=False) iqu_band_j=hp.smoothing(iqu_band_j,pol=1,fwhm=np.sqrt((smoothing_scale)**2-(beam_fwhm[ind_j])**2)*np.pi/(180.*60.),verbose=False) #alpha_radio=hp.smoothing(alpha_radio,fwhm=np.pi/180.,lmax=383) iqu_band_i=hp.ud_grade(iqu_band_i,nside_out=nside_out,order_in='ring') iqu_band_j=hp.ud_grade(iqu_band_j,nside_out=nside_out,order_in='ring') const=2.*(wl_i**2-wl_j**2) Delta_Q=(iqu_band_i[1]-iqu_band_j[1])/const Delta_U=(iqu_band_i[2]-iqu_band_j[2])/const alpha_u=alpha_radio*iqu_band_j[2] alpha_q=-alpha_radio*iqu_band_j[1] DQm=hp.ma(Delta_Q) DUm=hp.ma(Delta_U) aQm=hp.ma(alpha_q) aUm=hp.ma(alpha_u) sqi=hp.ma(sigma_q_i) sui=hp.ma(sigma_u_i) sqj=hp.ma(sigma_q_j) suj=hp.ma(sigma_u_j) salpha=hp.ma(delta_alpha_radio) alpham=hp.ma(alpha_radio) um=hp.ma(iqu_band_j[2]) qm=hp.ma(iqu_band_j[1]) Bl_factor=np.repeat(1.,3*nside_out) #ipdb.set_trace() if beam: Bl_factor=hp.gauss_beam(smoothing_scale*np.pi/(180.*60.),3*nside_out-1) pix_area=hp.nside2pixarea(nside_out) #ipdb.set_trace() mask_bool=np.repeat(False,npix_out) if gal_cut > 0: pix=np.arange(hp.nside2npix(nside_out)) x,y,z=hp.pix2vec(nside,pix,nest=0) mask_bool= np.abs(z)<= np.sin(gal_cut*np.pi/180.) #mask_bool1[np.where(np.sqrt(iqu_band_j[1]**2+iqu_band_j[2]**2)<.2e-6)]=True if not (mask_file is None): mask_hdu=fits.open(mask_file) mask=mask_hdu[1].data.field(0) mask_hdu.close() mask=hp.reorder(mask,n2r=1) mask=hp.ud_grade(mask,nside_out=128) mask_bool=~mask.astype(bool) fsky= 1. - np.sum(mask)/float(len(mask)) L=np.sqrt(fsky*4*np.pi) dl_eff=2*np.pi/L DQm.mask=mask_bool DUm.mask=mask_bool aQm.mask=mask_bool aUm.mask=mask_bool sqi.mask=mask_bool sui.mask=mask_bool sqj.mask=mask_bool suj.mask=mask_bool salpha.mask=mask_bool alpham.mask=mask_bool um.mask=mask_bool qm.mask=mask_bool #ipdb.set_trace() cross1=hp.anafast(DQm,map2=aUm)/Bl_factor**2 cross2=hp.anafast(DUm,map2=aQm)/Bl_factor**2 ##calculate theoretical variance for correlations N_dq=abs((sqi-sqj)**2).sum()*(pix_area/const)**2/(4.*np.pi) N_du=abs((sui-suj)**2).sum()*(pix_area/const)**2/(4.*np.pi) N_au=abs((salpha*um+alpham*suj+salpha*suj)**2).sum()*pix_area**2/(4.*np.pi) N_aq=abs((salpha*qm+alpham*sqj+salpha*sqj)**2).sum()*pix_area**2/(4.*np.pi) #ipdb.set_trace() return (cross1,cross2,N_dq,N_du,N_au,N_aq)
def main(): t1=time() radio_file='/data/wmap/faraday_MW_realdata.fits' cl_file='/home/matt/wmap/simul_scalCls.fits' output_prefix='/home/matt/quiet/quiet_maps/' nside=1024 nside_in=1024 npix=hp.nside2npix(nside) bands=[43.1,94.5] q_fwhm=[27.3,11.7] pix_area= np.sqrt(hp.nside2pixarea(1024))*60*180./np.pi noise_const_q=np.array([36./pix_area for f in q_fwhm])*1e-6 # noise_const_q=np.array([36./fwhm for fwhm in q_fwhm])*1e-6 centers=np.array([convertcenter([12,4],-39),convertcenter([5,12],-39),convertcenter([0,48],-48),convertcenter([22,44],-36)]) wl=np.array([299792458./(band*1e9) for band in bands]) synchrotron_file='/data/Planck/COM_CompMap_SynchrotronPol-commander_0256_R2.00.fits' dust_file='/data/Planck/COM_CompMap_DustPol-commander_1024_R2.00.fits' dust_t_file='/data/Planck/COM_CompMap_dust-commander_0256_R2.00.fits' dust_b_file='/data/Planck/COM_CompMap_ThermalDust-commander_2048_R2.00.fits' ##Dust intensity scaling factor hdu_dust_t=fits.open(dust_t_file) dust_t=hdu_dust_t[1].data.field('TEMP_ML') hdu_dust_t.close() dust_t=hp.reorder(dust_t,n2r=1) dust_t=hp.ud_grade(dust_t,nside_in) hdu_dust_b=fits.open(dust_b_file) dust_beta=hdu_dust_b[1].data.field('BETA_ML_FULL') hdu_dust_b.close dust_beta=hp.reorder(dust_beta,n2r=1) dust_beta=hp.ud_grade(dust_beta,nside_in) gamma_dust=6.626e-34/(1.38e-23*dust_t) krj_to_kcmb=np.array([1.,1.]) sync_factor=krj_to_kcmb*np.array([1e-6*(30./x)**2 for x in bands]) dust_factor=np.array([krj_to_kcmb[i]*1e-6*(np.exp(gamma_dust*353e9)-1)/(np.exp(gamma_dust*x*1e9)-1)* (x/353.)**(1+dust_beta) for i,x in enumerate(bands)]) print('Preparing Foregrounds') bl_40=hp.gauss_beam(40.*np.pi/(180.*60.),3*1024-1) bl_10=hp.gauss_beam(10.*np.pi/(180.*60.),3*1024-1) hdu_sync=fits.open(synchrotron_file) sync_q=hdu_sync[1].data.field(0) sync_u=hdu_sync[1].data.field(1) sync_q=hp.reorder(sync_q,n2r=1) tmp_alm=hp.map2alm(sync_q) tmp_alm=hp.almxfl(tmp_alm,1./bl_40) #simul_sync_q=hp.smoothing(sync_q,fwhm=40.*np.pi/(180.*60.),verbose=False,invert=True) sync_q=hp.alm2map(tmp_alm,nside_in,verbose=False) sync_u=hp.reorder(sync_u,n2r=1) tmp_alm=hp.map2alm(sync_u) tmp_alm=hp.almxfl(tmp_alm,1./bl_40) #simul_sync_q=hp.smoothing(sync_q,fwhm=40.*np.pi/(180.*60.),verbose=False,invert=True) sync_u=hp.alm2map(tmp_alm,nside_in,verbose=False) hdu_sync.close() hdu_dust=fits.open(dust_file) dust_q=hdu_dust[1].data.field(0) dust_u=hdu_dust[1].data.field(1) hdu_dust.close() dust_q=hp.reorder(dust_q,n2r=1) tmp_alm=hp.map2alm(dust_q) tmp_alm=hp.almxfl(tmp_alm,1./bl_10) #simul_dust_q=hp.smoothing(dust_q,fwhm=10.*np.pi/(180.*60.),verbose=False,invert=True) dust_q=hp.alm2map(tmp_alm,nside_in,verbose=False) dust_q_back=np.copy(dust_q) dust_u=hp.reorder(dust_u,n2r=1) tmp_alm=hp.map2alm(dust_u) tmp_alm=hp.almxfl(tmp_alm,1./bl_10) #simul_dust_q=hp.smoothing(dust_q,fwhm=10.*np.pi/(180.*60.),verbose=False,invert=True) dust_u=hp.alm2map(tmp_alm,nside_in,verbose=False) dust_u_back=np.copy(dust_u) print 'Generating Map' cls=hp.read_cl(cl_file) simul_cmb=hp.sphtfunc.synfast(cls,nside,fwhm=0.,new=1,pol=1); alpha_radio=hp.read_map(radio_file,hdu='maps/phi'); alpha_radio=hp.ud_grade(alpha_radio,nside_out=nside,order_in='ring',order_out='ring') num_wl=len(wl) no_noise=[] t_array=np.zeros((num_wl,npix)) q_array=np.zeros((num_wl,npix)) sigma_q=np.zeros((num_wl,npix)) u_array=np.zeros((num_wl,npix)) sigma_u=np.zeros((num_wl,npix)) for i in range(num_wl): print('\tFrequency: {0:2.1f}'.format(bands[i])) tmp_cmb=rotate_tqu(simul_cmb,wl[i],alpha_radio); no_noise.append(hp.smoothing(np.copy(tmp_cmb), fwhm=q_fwhm[i]*np.pi/(180*60.),pol=1,verbose=False)) sigma_q[i]=np.random.normal(0,1,npix)*noise_const_q[i] sigma_u[i]=np.random.normal(0,1,npix)*noise_const_q[i] tmp_cmb[1]+= np.copy( dust_factor[i]*dust_q+sync_factor[i]*sync_q ) tmp_cmb[2]+= np.copy( dust_factor[i]*dust_u+sync_factor[i]*sync_u ) tmp_out=hp.sphtfunc.smoothing(tmp_cmb,fwhm=q_fwhm[i]*np.pi/(180.*60.),pol=1,verbose=False) t_array[i],q_array[i],u_array[i]=tmp_out #sigma_q[i]=hp.sphtfunc.smoothing(tmp_q,fwhm=np.pi/180.) #sigma_u[i]=hp.sphtfunc.smoothing(tmp_u,fwhm=np.pi/180.) print "Time to Write Fields" dx=1./(60.)*3 nx=np.int(15/dx) ny=nx all_pix=[] field_pix=[] square_pix=[] quiet_mask=np.zeros(npix) prim=fits.PrimaryHDU() prim.header['COMMENT']="Simulated Quiet Data" prim.header['COMMENT']="Created using CAMB" for p in xrange(len(centers)): coords=regioncoords(centers[p,0],centers[p,1],dx,nx,ny) coords_sky=SkyCoord(ra=coords[:,0],dec=coords[:,1],unit=u.degree,frame='fk5') phi=coords_sky.galactic.l.deg*np.pi/180. theta=(90-coords_sky.galactic.b.deg)*np.pi/180. pixels=hp.ang2pix(nside,theta,phi) quiet_mask[pixels]=1 unique_pix=(np.unique(pixels).tolist()) field_pix.append(unique_pix) square_pix.append(pixels) all_pix.extend(unique_pix) pix_col=fits.Column(name='PIXEL',format='1J',array=unique_pix) for f in xrange(num_wl): region_mask=np.zeros(npix) region_mask[pixels]=1 region_map_t=np.array(t_array[f][pixels]).reshape((nx,ny)) region_map_q=np.array(q_array[f][pixels]).reshape((nx,ny)) region_map_u=np.array(u_array[f][pixels]).reshape((nx,ny)) region_delta_q=np.array(sigma_q[f][pixels]).reshape((nx,ny)) region_delta_u=np.array(sigma_u[f][pixels]).reshape((nx,ny)) prim=fits.PrimaryHDU() q_head=fits.ImageHDU([region_map_t,region_map_q,region_map_u],name="STOKES IQU") q_head.header['TFIELDS']=(3,'number of fields in each row') q_head.header['TTYPE1']=('SIGNAL', "STOKES I, Temperature") q_head.header['TUNIT1']=('K_{CMB} Thermodynamic', 'Physical Units of Map') q_head.header['TTYPE2']='STOKES Q' q_head.header['TUNIT2']=('K_{CMB} Thermodynamic', 'Physical Units of Map') q_head.header['TTYPE3']='STOKES U' q_head.header['TUNIT3']=('K_{CMB} Thermodynamic', 'Physical Units of Map') q_head.header['TFORM1']='E' q_head.header['TFORM1']='E' q_head.header['TFORM2']='E' q_head.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") q_head.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") q_head.header["COORDSYS"]=('G','Pixelization coordinate system') q_head.header['NSIDE']=(1024,'Healpix Resolution paramter') q_head.header['OBJECT']=('FULLSKY','Sky coverage, either FULLSKY or PARTIAL') q_head.header['INDXSCHM']=('EXPLICIT','indexing : IMPLICIT of EXPLICIT') err_head=fits.ImageHDU([region_delta_q,region_delta_u],name="Q/U UNCERTAINTIES") err_head.header['TFIELDS']=(2,'number of fields in each row') err_head.header['NSIDE']=1024 err_head.header['ORDERING']='RING' err_head.header['TTYPE1']='SIGMA Q' err_head.header['TUNIT1']=('K_{CMB} Thermodynamic', 'Physical Units of Map') err_head.header['TTYPE2']='SIGMA U' err_head.header['TUNIT2']=('K_{CMB} Thermodynamic', 'Physical Units of Map') err_head.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") err_head.header['OBJECT']=('PARTIAL','Sky coverage, either FULLSKY or PARTIAL') err_head.header['INDXSCHM']=('EXPLICIT','indexing : IMPLICIT of EXPLICIT') m_head=fits.ImageHDU(region_mask,name='MASK') sqr_pix_col=fits.Column(name='PIXELS',format='1J',array=pixels) sqr_pix_cols=fits.ColDefs([sqr_pix_col]) sqr_pix_head=fits.BinTableHDU.from_columns(sqr_pix_cols) hdulist=fits.HDUList([prim,q_head,err_head,m_head,sqr_pix_head]) hdulist.writeto(output_prefix+"quiet_simulated_{:.1f}_cmb{:1d}.fits".format(bands[f],p+1),clobber=True) print '{:.1f}_cmb{:1d}.fits'.format(bands[f],p+1) mask_head=fits.ImageHDU(quiet_mask,name='MASK') pix_col=fits.Column(name='PIXEL',format='1J',array=all_pix) field_pix_col1=fits.Column(name='PIXELS FIELD 1',format='1J',array=field_pix[0]) field_pix_col2=fits.Column(name='PIXELS FIELD 2',format='1J',array=field_pix[1]) field_pix_col3=fits.Column(name='PIXELS FIELD 3',format='1J',array=field_pix[2]) field_pix_col4=fits.Column(name='PIXELS FIELD 4',format='1J',array=field_pix[3]) sqr_pix_col1=fits.Column(name='PIXELS FIELD 1',format='1J',array=square_pix[0]) sqr_pix_col2=fits.Column(name='PIXELS FIELD 2',format='1J',array=square_pix[1]) sqr_pix_col3=fits.Column(name='PIXELS FIELD 3',format='1J',array=square_pix[2]) sqr_pix_col4=fits.Column(name='PIXELS FIELD 4',format='1J',array=square_pix[3]) cols1=fits.ColDefs([sqr_pix_col1,sqr_pix_col2,sqr_pix_col3,sqr_pix_col4]) tbhdu1=fits.BinTableHDU.from_columns(cols1) tbhdu1.header['TFIELDS']=(4,'number of fields in each row') tbhdu1.header["TTYPE1"]=("PIXELS CMB FIELD 1","SQUARE PIXEL NUMBER BY FIELD") tbhdu1.header["TTYPE2"]=("PIXELS CMB FIELD 2","SQUARE PIXEL NUMBER BY FIELD") tbhdu1.header["TTYPE3"]=("PIXELS CMB FIELD 3","SQUARE PIXEL NUMBER BY FIELD") tbhdu1.header["TTYPE4"]=("PIXELS CMB FIELD 4","SQUARE PIXEL NUMBER BY FIELD") tbhdu1.header["EXTNAME"]="SQUARE PIXELS" tbhdu1.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") tbhdu1.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") tbhdu1.header["NSIDE"]=(nside,'Healpix Resolution paramter') tbhdu1.header['OBJECT']=('PARTIAL','Sky coverage, either FULLSKY or PARTIAL') tbhdu1.header['OBS_NPIX']=(len(all_pix),'Number of pixels observed') tbhdu1.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') tbhdu1.header["COORDSYS"]=('G','Pixelization coordinate system') for i in xrange(num_wl): cut_t,cut_q,cut_u=t_array[i][all_pix],q_array[i][all_pix],u_array[i][all_pix] cut_dq,cut_du=sigma_q[i][all_pix],sigma_u[i][all_pix] col_t=fits.Column(name='SIGNAL',format='1E',unit='K_{CMB}',array=cut_t) col_q=fits.Column(name='STOKES Q',format='1E',unit='K_{CMB}',array=cut_q) col_u=fits.Column(name='STOKES U',format='1E',unit='K_{CMB}',array=cut_u) col_dq=fits.Column(name='Q ERROR',format='1E',unit='K_{CMB}',array=cut_dq) col_du=fits.Column(name='U ERROR',format='1E',unit='K_{CMB}',array=cut_du) cols=fits.ColDefs([pix_col,col_q,col_u,col_dq,col_du]) tbhdu=fits.BinTableHDU.from_columns(cols) tbhdu.header['TFIELDS']=(5,'number of fields in each row') tbhdu.header["TTYPE2"]=("SIGNAL","STOKES T") tbhdu.header["EXTNAME"]="SIGNAL" tbhdu.header['POLAR']= 'T' tbhdu.header['POLCCONV']=('COSMO','Coord. Convention for polarisation COSMO/IAU') tbhdu.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") tbhdu.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") tbhdu.header["NSIDE"]=(1024,'Healpix Resolution paramter') tbhdu.header['OBJECT']=('PARTIAL','Sky coverage, either FULLSKY or PARTIAL') tbhdu.header['OBS_NPIX']=(len(all_pix),'Number of pixels observed') tbhdu.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') tbhdu.header["COORDSYS"]=('G','Pixelization coordinate system') tblist=fits.HDUList([prim,tbhdu]) tblist.writeto(output_prefix+'quiet_partial_simulated_{:.1f}.fits'.format(bands[i]),clobber=True) q_head=fits.ImageHDU(np.array([t_array[i],q_array[i],u_array[i]]), name='STOKES IQU') q_head.header['TFIELDS']=(3,'number of fields in each row') q_head.header['TYPE1']=('SIGNAL', "STOKES I, Temperature") q_head.header['TYPE2']='STOKES Q' q_head.header['TYPE3']='STOKES U' q_head.header['TUNIT1']=('K_{CMB} Thermodynamic', 'Physical Units of Map') q_head.header['TUNIT2']=('K_{CMB} Thermodynamic', 'Physical Units of Map') q_head.header['TUNIT3']=('K_{CMB} Thermodynamic', 'Physical Units of Map') q_head.header['TFORM1']='E' q_head.header['TFORM1']='E' q_head.header['TFORM2']='E' q_head.header['EXTNAME']='STOKES IQU' q_head.header['POLAR']= 'T' q_head.header['POLCCONV']=('COSMO','Coord. Convention for polarisation COSMO/IAU') q_head.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") q_head.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") q_head.header['NSIDE']=(1024,'Healpix Resolution paramter') q_head.header['OBJECT']=('FULLSKY','Sky coverage, either FULLSKY or PARTIAL') q_head.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') q_head.header['BAD_DATA']=(hp.UNSEEN,'Sentinel value given to bad pixels') q_head.header["COORDSYS"]=('G','Pixelization coordinate system') ######################### theo_head=fits.ImageHDU(no_noise[i], name='No Noise IQU') theo_head.header['TFIELDS']=(3,'number of fields in each row') theo_head.header['TYPE1']=('SIGNAL', "STOKES I, Temperature") theo_head.header['TYPE2']='STOKES Q' theo_head.header['TYPE3']='STOKES U' theo_head.header['TUNIT1']=('K_{CMB} Thermodynamic', 'Physical Units of Map') theo_head.header['TUNIT2']=('K_{CMB} Thermodynamic', 'Physical Units of Map') theo_head.header['TUNIT3']=('K_{CMB} Thermodynamic', 'Physical Units of Map') theo_head.header['TFORM1']='E' theo_head.header['TFORM1']='E' theo_head.header['TFORM2']='E' theo_head.header['EXTNAME']='no noise iqu' theo_head.header['POLAR']= 'T' theo_head.header['POLCCONV']=('COSMO','Coord. Convention for polarisation COSMO/IAU') theo_head.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") theo_head.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") theo_head.header['NSIDE']=(1024,'Healpix Resolution paramter') theo_head.header['OBJECT']=('FULLSKY','Sky coverage, either FULLSKY or PARTIAL') theo_head.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') theo_head.header['BAD_DATA']=(hp.UNSEEN,'Sentinel value given to bad pixels') theo_head.header["COORDSYS"]=('G','Pixelization coordinate system') #################################### #tblist=fits.HDUList([prim,tbhdu]) err_head=fits.ImageHDU(np.array([sigma_q[i],sigma_u[i]]),name='Q/U UNCERTAINTIES') err_head.header['TFIELDS']=(2,'number of fields in each row') err_head.header['NSIDE']=1024 err_head.header['ORDERING']='RING' err_head.header['TTYPE1']='SIGMA Q' err_head.header['TTYPE2']='SIGMA U' err_head.header['TUNIT1']=('K_{CMB} Thermodynamic', 'Physical Units of Map') err_head.header['TUNIT2']=('K_{CMB} Thermodynamic', 'Physical Units of Map') err_head.header['TFORM1']='E' err_head.header['TFORM2']='E' err_head.header['EXTNAME']='Q/U UNCERTAINTIES' err_head.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") err_head.header['OBJECT']=('FULLSKY','Sky coverage, either FULLSKY or PARTIAL') err_head.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') err_head.header['BAD_DATA']=(hp.UNSEEN,'Sentinel value given to bad pixels') cols=fits.ColDefs([field_pix_col1,field_pix_col2,field_pix_col3,field_pix_col4]) tbhdu=fits.BinTableHDU.from_columns(cols) tbhdu.header['TFIELDS']=(4,'number of fields in each row') tbhdu.header["TTYPE1"]=("PIXELS CMB FIELD 1","PIXEL NUMBER BY FIELD") tbhdu.header["TTYPE2"]=("PIXELS CMB FIELD 2","PIXEL NUMBER BY FIELD") tbhdu.header["TTYPE3"]=("PIXELS CMB FIELD 3","PIXEL NUMBER BY FIELD") tbhdu.header["TTYPE4"]=("PIXELS CMB FIELD 4","PIXEL NUMBER BY FIELD") tbhdu.header["EXTNAME"]="FIELD PIXELS" tbhdu.header['PIXTYPE']=("HEALPIX","HEALPIX pixelisation") tbhdu.header['ORDERING']=("RING","Pixel order scheme, either RING or NESTED") tbhdu.header["NSIDE"]=(nside,'Healpix Resolution paramter') tbhdu.header['OBJECT']=('PARTIAL','Sky coverage, either FULLSKY or PARTIAL') tbhdu.header['OBS_NPIX']=(len(all_pix),'Number of pixels observed') tbhdu.header['INDXSCHM']=('IMPLICIT','indexing : IMPLICIT of EXPLICIT') tbhdu.header["COORDSYS"]=('G','Pixelization coordinate system') hdulist=fits.HDUList([prim,q_head,err_head,mask_head,tbhdu,tbhdu1,theo_head]) hdulist.writeto(output_prefix+"quiet_simulated_{:.1f}.fits".format(bands[i]),clobber=True) print "quiet_simulated_{:.1f}.fits".format(bands[i])