def main(nsim=1, fnl=0.0):
nl = 1024
nside_fnl = 512
# Load map, mll
print ""
print "Loading alm_g, alm_ng and creating map..."
fn_almg = ('data/fnl_sims/alm_l_%04d_v3.fits' % (nsim,))
#fn_almg = ('data/fnl_sims/alm_l_%i.fits' % (nsim,))
almg = hp.read_alm(fn_almg)
#almg = almg[:hp.Alm.getsize(nl)]
fn_almng = ('data/fnl_sims/alm_nl_%04d_v3.fits' % (nsim,))
#fn_almng = ('data/fnl_sims/alm_nl_%i.fits' % (nsim,))
almng = hp.read_alm(fn_almng)
#almng = almng[:hp.Alm.getsize(nl)]
alm = almg * (2.7e6) + fnl * almng * (2.7e6) # convert to units of uK to be consistent with other maps
map_sim_fnl = hp.alm2map(alm, nside=nside_fnl)
#print "Normalizing map..."
#map_sim_fnl *= (1e6 * 2.7) # convert to units of uK to be consistent with other maps
fn_map = 'data/fnl_sims/map_fnl_%i_sim_%i.fits' % (int(fnl), nsim)
print "Writing map: %s" % fn_map
hp.write_map(fn_map, map_sim_fnl)
def aps(rlz, qobj, xobj, wfac, flens, fcib, **kwargs_ov):
Lmax = qobj.olmax
cl = np.zeros((len(rlz), 7, Lmax + 1))
for q in qobj.qlist:
for i, r in enumerate(
tqdm.tqdm(rlz,
ncols=100,
desc='aps (' + qobj.qtype + ',' + q + ')')):
if misctools.check_path(xobj.fcli[q][r], **kwargs_ov): continue
# load qlm
alm = quad_func.load_rec_alm(qobj, q, r, mean_sub=True)[0]
#alm = pickle.load(open(qobj.f[q].alm[r],"rb"))[0]
#mf = pickle.load(open(qobj.f[q].mfalm[r],"rb"))[0]
#alm -= mf
# auto spectrum
cl[i, 0, :] = csu.alm2cl(Lmax, alm) / qobj.wn[4]
if r > 0:
# load input klm
klm = hp.read_alm(flens['IN'][r])
klm = csu.lm_healpy2healpix(klm, 4096)[:Lmax + 1, :Lmax + 1]
# cross with input klm
cl[i, 1, :] = csu.alm2cl(Lmax, alm, klm) / qobj.wn[2]
# load reconstructed klm
klm = hp.read_alm(flens['MV'][r])
klm = csu.lm_healpy2healpix(klm, 4096)[:Lmax + 1, :Lmax + 1]
# cross with lens
cl[i, 2, :] = csu.alm2cl(Lmax, alm, klm) / wfac['ik']
# lens auto
cl[i, 3, :] = csu.alm2cl(Lmax, klm) / wfac['kk']
# load cib alm
Ilm = pickle.load(open(fcib[r], "rb"))
# cross with cib
cl[i, 4, :] = csu.alm2cl(Lmax, alm, Ilm) / wfac['iI']
# cib
cl[i, 5, :] = csu.alm2cl(Lmax, Ilm) / wfac['II']
# lens x cib
cl[i, 6, :] = csu.alm2cl(Lmax, Ilm, klm) / wfac['kI']
np.savetxt(xobj.fcli[q][r],
np.concatenate((qobj.l[None, :], cl[i, :, :])).T)
# save to files
if rlz[-1] >= 2 and not misctools.check_path(xobj.fmcl[q], **
kwargs_ov):
i0 = max(0, 1 - rlz[0])
np.savetxt(
xobj.fmcl[q],
np.concatenate(
(qobj.l[None, :], np.average(cl[i0:, :, :], axis=0),
np.std(cl[i0:, :, :], axis=0))).T)
def compute_pol_derivatives(self, fromalm=False):
"""
Compute derivatives of the input polarization components (healpix).
Not updated for dichroic for the moment.
Parameters
----------
fromalm : bool, optional
If True, loads alm file from disk instead of fourier
transform the input map. Automatically turns True if you input
alm files. False otherwise.
Examples
----------
>>> filename = 's4cmb/data/test_data_set_lensedCls.dat'
>>> hpmap = HealpixFitsMap(input_filename=filename, fwhm_in=3.5,
... nside_in=16, compute_derivatives=True, map_seed=489237)
>>> hasattr(hpmap, 'dIdp')
True
"""
if fromalm:
Elm = hp.read_alm(self.input_filename[1])
Blm = hp.read_alm(self.input_filename[2])
else:
alm = hp.map2alm([self.I, self.Q, self.U], self.lmax)
Elm = alm[1]
Blm = alm[2]
# lmax = hp.Alm.getlmax(Elm.size)
if "P1" in self.derivatives_type:
out = alm2map_spin_der1([Elm, Blm], self.nside_in, 2)
self.dQdt = out[1][0]
self.dUdt = out[1][1]
self.dQdp = out[2][0]
self.dUdp = out[2][1]
else:
warnings.warn("""
Computation of second order polarization derivatives not
implemented yet. Set to 0.
""")
out = alm2map_spin_der1([Elm, Blm], self.nside_in, 2)
self.dQdt = out[1][0]
self.dUdt = out[1][1]
self.dQdp = out[2][0]
self.dUdp = out[2][1]
self.d2Qd2t = np.zeros_like(self.dQdt)
self.d2Qd2p = np.zeros_like(self.dQdt)
self.d2Qdpdt = np.zeros_like(self.dQdt)
self.d2Ud2t = np.zeros_like(self.dQdt)
self.d2Ud2p = np.zeros_like(self.dQdt)
self.d2Udpdt = np.zeros_like(self.dQdt)
def _get_real(self, ifile):
from orphics.maps import filter_alms
alm = hp.read_alm(ifile)
alm = filter_alms(alm, 8, 2048)
omap = hp.alm2map(alm, nside=self.nside)
return omap
def get_cmb_alm_v0p5(
cmb_set,
phi_set,
i,
path='/scratch/r/rbond/msyriac/data/sims/signal/v0.5_lenstest/'):
fname = path + f"fullskyLensedUnaberratedCMB_alm_cmb_set_{cmb_set:02d}_phi_set_{phi_set:02d}_{i:05d}.fits"
return hp.read_alm(fname, hdu=(1, 2, 3))
def gal2equ(in_file, out_file, smooth, eulers=None):
e2g = np.array([[-0.054882486, -0.993821033, -0.096476249],
[ 0.494116468, -0.110993846, 0.862281440],
[-0.867661702, -0.000346354, 0.497154957]]) # intrinsic rotation
g2e = np.linalg.inv(e2g)
eps = 23.452294 - 0.0130125 - 1.63889E-6 + 5.02778E-7
eps = eps * np.pi / 180.
e2q = np.array([[1., 0. , 0. ],
[0., np.cos( eps ), -1. * np.sin( eps )],
[0., np.sin( eps ), np.cos( eps ) ]])
g2q = np.dot(e2q , g2e)
psi = np.arctan2(g2q[1,2],g2q[0,2])
theta = np.arccos(g2q[2,2])
phi = np.arctan2(g2q[2,1],-g2q[2,0]) # deduced from zyz rotation matrix
fwhm = smooth*((2*np.pi)/360)
alms = hp.read_alm(in_file)
hp.smoothalm(alms, fwhm=fwhm)
if eulers == None:
hp.rotate_alm(alms, phi, theta, psi) # reverse rotation order -> extrinsic rotation
print('Euler angles (zyz) = ', str(np.rad2deg(phi)), str(np.rad2deg(theta)), str(np.rad2deg(psi)))
else:
eulers = np.deg2rad(eulers)
hp.rotate_alm(alms, eulers[0], eulers[1], eulers[2])
print('Euler angles (zyz) = ', str(np.rad2deg(eulers[0])), str(np.rad2deg(eulers[1])), str(np.rad2deg(eulers[2])))
print(e2q)
hp.write_alm(out_file, alms)
def klm_2_map(klmname, mapname, nsides):
# read in planck alm convergence data
planck_lensing_alm = hp.read_alm(klmname)
filtered_alm = zero_modes(planck_lensing_alm, 100)
# generate map from alm data
planck_lensing_map = hp.sphtfunc.alm2map(filtered_alm, nsides, lmax=4096)
hp.write_map(mapname, planck_lensing_map, overwrite=True)
def get_sim_qlm(self, k, idx, lmax=None):
"""Returns a QE estimate, by computing and caching it if not done previously.
Args:
k: quadratic estimator key
idx: simulation index
lmax: optionally reduces the lmax of the output healpy array.
"""
assert k in self.keys, (k, self.keys)
if lmax is None:
lmax = self.get_lmax_qlm(k)
assert lmax <= self.get_lmax_qlm(k)
if k in ['p_tp', 'x_tp', 'f_tp', 's_tp']:
return self.get_sim_qlm('%stt' % k[0], idx,
lmax=lmax) + self.get_sim_qlm(
'%s_p' % k[0], idx, lmax=lmax)
if k in ['p_te', 'p_tb', 'p_eb', 'x_te', 'x_tb', 'x_eb']:
return self.get_sim_qlm(k[0] + k[2] + k[3], idx,
lmax=lmax) + self.get_sim_qlm(
k[0] + k[3] + k[2], idx, lmax=lmax)
if '_bh_' in k: # Bias-hardening
assert self.resplib is not None, 'resplib arg necessary for this'
kQE, ksource = k.split('_bh_')
assert len(ksource) == 1 and ksource + kQE[1:] in self.keys, (
ksource, kQE)
assert self.get_lmax_qlm(kQE) == self.get_lmax_qlm(
ksource + kQE[1:]), 'fix this (easy)'
lmax = self.get_lmax_qlm(kQE)
wL = self.resplib.get_response(kQE, ksource) * ut.cli(
self.resplib.get_response(ksource + kQE[1:], ksource))
ret = self.get_sim_qlm(kQE, idx, lmax=lmax)
return ret - hp.almxfl(
self.get_sim_qlm(ksource + kQE[1:], idx, lmax=lmax), wL)
assert k in self.keys_fund, (k, self.keys_fund)
fname = os.path.join(
self.lib_dir,
'sim_%s_%04d.fits' % (k, idx) if idx != -1 else 'dat_%s.fits' % k)
if not os.path.exists(fname):
if k in ['ptt', 'xtt']: self._build_sim_Tgclm(idx)
elif k in ['p_p', 'x_p']: self._build_sim_Pgclm(idx)
elif k in ['p', 'x']: self._build_sim_MVgclm(idx)
elif k in ['f']: self._build_sim_f(idx)
elif k in ['stt']: self._build_sim_stt(idx)
elif k in ['ftt']: self._build_sim_ftt(idx)
elif k in ['f_p']: self._build_sim_f_p(idx)
elif k in ['ntt']: self._build_sim_ntt(idx)
elif k in ['a_p']: self._build_sim_a_p(idx)
elif k in [
'ptt', 'pte', 'pet', 'ptb', 'pbt', 'pee', 'peb', 'pbe',
'pbb', 'xtt', 'xte', 'xet', 'xtb', 'xbt', 'xee', 'xeb',
'xbe', 'xbb'
]:
self._build_sim_xfiltMVgclm(idx, k)
else:
assert 0, k
return ut.alm_copy(hp.read_alm(fname), lmax=lmax)
def read_alm(path, has_polarization=True, unit=None, map_dist=None):
"""Read :math:`a_{\ell m}` from a FITS file
Parameters
----------
path : str
absolute or relative path to local file or file available remotely.
has_polarization : bool
read only temperature alm from file or also polarization
map_dist : pysm.MapDistribution
:math:`\ell_{max}` should be the same of the :math:`\ell_{max}` in the file
and :math:`m_{max}=\ell_{max}`.
"""
filename = utils.RemoteData().get(path)
mpi_comm = None if map_dist is None else map_dist.mpi_comm
if (mpi_comm is not None and mpi_comm.rank == 0) or (mpi_comm is None):
alm = np.complex128(
hp.read_alm(filename, hdu=(1, 2, 3) if has_polarization else 1)
)
if unit is None:
unit = u.Unit(extract_hdu_unit(filename))
if mpi_comm is not None:
raise NotImplementedError
else:
local_alm = alm
return local_alm * unit
def __init__(
self,
filename,
input_units="uK_CMB",
input_reference_frequency=None,
nside=None,
target_shape=None,
target_wcs=None,
precompute_output_map=True,
has_polarization=True,
map_dist=None,
):
"""Generic component based on Precomputed Alms
Load a set of Alms from a FITS file and generate maps at the requested
resolution and frequency assuming the CMB black body spectrum.
A single set of Alms is used for all frequencies requested by PySM,
consider that PySM expects the output of components to be in uK_RJ.
See more details at https://so-pysm-models.readthedocs.io/en/latest/so_pysm_models/models.html
Parameters
----------
filename : string
Path to the input Alms in FITS format
input_units : string
Input unit strings as defined by pysm.convert_units, e.g. K_CMB, uK_RJ, MJysr
input_reference_frequency: float
If input units are K_RJ or Jysr, the reference frequency
nside : int
HEALPix NSIDE of the output maps
precompute_output_map : bool
If True (default), Alms are transformed into a map in the constructor,
if False, the object only stores the Alms and generate the map at each
call of the signal method, this is useful to generate maps convolved
with different beams
has_polarization : bool
whether or not to simulate also polarization maps
Default: True
"""
super().__init__(nside=nside, map_dist=map_dist)
self.shape = target_shape
self.wcs = target_wcs
self.filename = filename
self.input_units = u.Unit(input_units)
self.has_polarization = has_polarization
alm = np.complex128(
hp.read_alm(self.filename,
hdu=(1, 2, 3) if self.has_polarization else 1))
self.equivalencies = (None if input_reference_frequency is None else
u.cmb_equivalencies(input_reference_frequency))
if precompute_output_map:
self.output_map = self.compute_output_map(alm)
else:
self.alm = alm
def load_alms(component, id):
if component == 'cmb':
cmb_tlm = hp.read_alm(
'/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_lensed_scl_cmb_000_alm_mc_%04d.fits'
% int(id),
hdu=1)
cmb_elm = hp.read_alm(
'/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_lensed_scl_cmb_000_alm_mc_%04d.fits'
% int(id),
hdu=2)
cmb_blm = hp.read_alm(
'/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_lensed_scl_cmb_000_alm_mc_%04d.fits'
% int(id),
hdu=3)
return cmb_tlm, cmb_elm, cmb_blm
else:
print('unclear request of loading alms. Exiting..')
sys.exit()
def get_sim_plm(idx):
r"""
Args:
idx: simulation index
Returns:
lensing potential :math:`\phi_{LM}` simulation healpy alm array
"""
return hp.read_alm('/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_unlensed_scl_cmb_000_tebplm_mc_%04d.fits'% idx, hdu=4)
def get_sim_blm(idx):
"""
Args:
idx: simulation index
Returns:
unlensed B-polarization simulation healpy alm array
"""
return 1e6 * hp.read_alm('/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_unlensed_scl_cmb_000_tebplm_mc_%04d.fits'% idx, hdu=3)
def get_sim_tlm(idx):
"""
Args:
idx: simulation index
Returns:
lensed temperature simulation healpy alm array
"""
return 1e6 * hp.read_alm('/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_lensed_scl_cmb_000_alm_mc_%04d.fits'%idx, hdu=1)
def _load_alm(self):
""" Load the alm expansion and place it in the node-shared memory
"""
if self._rank == 0:
timer = Timer()
timer.start()
alm, mmax = hp.read_alm(self._almfile, return_mmax=True)
nalm = len(alm)
lmax = hp.Alm.getlmax(nalm, mmax)
alm = [alm]
if self._pol:
for hdu in [2, 3]:
alm.append(hp.read_alm(self._almfile, hdu=hdu))
alm = np.vstack(alm)
nalm = len(alm)
# If necessary, truncate the expansion to sufficient lmax
self._lmax = min(lmax, self._lmax)
self._mmax = min(mmax, self._lmax)
if self._lmax < lmax:
sz = hp.Alm.getsize(self._lmax, self._mmax)
new_alm = np.zeros([nalm, sz], dtype=np.complex)
for ell in range(self._lmax + 1):
for m in range(min(ell, self._mmax)):
i = hp.Alm.getidx(self._lmax, ell, m)
j = hp.Alm.getidx(lmax, ell, m)
new_alm[:, i] = alm[:, j]
alm = new_alm
lmax = self._lmax
mmax = self._mmax
# Suppress any primordial monopole or dipole
for ell in range(min(2, lmax + 1)):
for m in range(min(ell + 1, mmax + 1)):
ind = hp.Alm.getidx(lmax, 1, m)
alm[0, ind] = 0
timer.stop()
timer.report("load CMB alm")
else:
alm, lmax, mmax = None, None, None
self._alm = self._comm.bcast(alm)
self._lmax = self._comm.bcast(lmax)
self._mmax = self._comm.bcast(mmax)
return
def sim_iamp(i, M, palm, lmax, rlmin, rlmax, Ag, ocl, lcl, nl, beta, freq):
fname = '/global/homes/t/toshiyan/scratch/plk_biref/test/glm_' + str(
freq) + '_' + str(i).zfill(3) + '.pkl'
if misctools.check_path(fname, verbose=False):
glm, Ealm, Balm = pickle.load(open(fname, "rb"))
else:
alms = hp.read_alm(
'/project/projectdirs/sobs/v4_sims/mbs/cmb/fullskyLensedUnabberatedCMB_alm_set00_'
+ str(i).zfill(5) + '.fits',
hdu=(1, 2, 3))
#Talm = cs.utils.lm_healpy2healpix( alms[0], 5100 ) [:lmax+1,:lmax+1] / CMB.Tcmb
Ealm = cs.utils.lm_healpy2healpix(
alms[1], 5100)[:lmax + 1, :lmax + 1] / CMB.Tcmb
Balm = cs.utils.lm_healpy2healpix(
alms[2], 5100)[:lmax + 1, :lmax + 1] / CMB.Tcmb
# biref
#print('birefringence')
Ealm, Balm = ana.ebrotate(beta, Ealm, Balm)
# add noise and filtering (temp)
#print('add noise')
#Talm += cs.utils.gauss1alm(lmax,nl[0,:])
Ealm += cs.utils.gauss1alm(lmax, nl[1, :])
Balm += cs.utils.gauss1alm(lmax, nl[2, :])
#print('mask')
#Talm = cs.utils.mulwin(Talm,M)
Ealm, Balm = cs.utils.mulwin_spin(Ealm, Balm, M)
# simple diagonal c-inverse
#print('reconstruction')
Fl = np.zeros((3, lmax + 1, lmax + 1))
for l in range(rlmin, rlmax):
Fl[:, l, 0:l + 1] = 1. / ocl[:3, l, None]
#Talm *= Fl[0,:,:]
fEalm = Ealm * Fl[1, :, :]
fBalm = Balm * Fl[2, :, :]
# compute unnormalized estiamtors
#glm['TE'], clm['TE'] = cs.rec_iamp.qte(lmax,rlmin,rlmax,lcl[3,:],Talm,Ealm)
#glm['TB'], clm['TB'] = cs.rec_iamp.qtb(lmax,rlmin,rlmax,lcl[3,:],Talm,Balm)
#glm['EE'], clm['EE'] = cs.rec_iamp.qee(lmax,rlmin,rlmax,lcl[1,:],Ealm,Ealm)
glm = cs.rec_iamp.qeb(lmax, rlmin, rlmax, ocl[1, :] - ocl[2, :], fEalm,
fBalm)
#glm['BB'], clm['BB'] = cs.rec_iamp.qbb(lmax,rlmin,rlmax,lcl[1,:],Balm,Balm)
#print('cross spec')
pickle.dump((glm, Ealm, Balm),
open(fname, "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
cl = cs.utils.alm2cl(lmax, Ag['EB'][:, None] * glm, palm)
W2 = np.mean(M**2)
EB = cs.utils.alm2cl(lmax, Ealm, Balm) / W2
return cl, EB
def klm_2_product(klmname, width, maskname, nsides, lmin, subtract_mf=False, writename=None):
# read in planck alm convergence data
planck_lensing_alm = hp.read_alm(klmname)
lmax = hp.Alm.getlmax(len(planck_lensing_alm))
if subtract_mf:
mf_alm = hp.read_alm('maps/mf_klm.fits')
planck_lensing_alm = planck_lensing_alm - mf_alm
# if you want to smooth with a gaussian
if width > 0:
# transform a gaussian of FWHM=width in real space to harmonic space
k_space_gauss_beam = hp.gauss_beam(fwhm=width.to('radian').value, lmax=lmax)
# if truncating small l modes
if lmin > 0:
# zero out small l modes in k-space filter
k_space_gauss_beam[:lmin] = 0
# smooth in harmonic space
filtered_alm = hp.smoothalm(planck_lensing_alm, beam_window=k_space_gauss_beam)
else:
# if not smoothing with gaussian, just remove small l modes
filtered_alm = zero_modes(planck_lensing_alm, lmin)
planck_lensing_map = hp.sphtfunc.alm2map(filtered_alm, nsides, lmax=lmax)
# mask map
importmask = hp.read_map(maskname)
if nsides < 2048:
mask_lowres_proper = hp.ud_grade(importmask.astype(float), nside_out=1024).astype(float)
finalmask = np.where(mask_lowres_proper == 1., True, False).astype(bool)
else:
finalmask = importmask.astype(np.bool)
# set mask, invert
smoothed_masked_map = hp.ma(planck_lensing_map)
smoothed_masked_map.mask = np.logical_not(finalmask)
if writename:
hp.write_map('%s.fits' % writename, smoothed_masked_map.filled(), overwrite=True, dtype=np.single)
return smoothed_masked_map.filled()
def alm2map_masked(mask_path,data_path):
mask=hp.read_map(mask_path)
alm=hp.read_alm(data_path)
map=hp.sphtfunc.alm2map(alm,nside)
map_masked=hp.ma(map)
map_masked.mask=np.logical_not(mask)
plt.figure()
hp.mollview(map_masked)
plt.savefig("/home/yhwu/pic/alm2map_masked.png",dpi=1000)
plt.clf()
def run_cmbmap(pathname, overwr):
"""
Derives CMB powerspectrum directly from alm data of pure CMB.
"""
nsi = csu.nside_out[1]
cmb_tlm = hp.read_alm(
'/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_lensed_scl_cmb_000_alm_mc_%04d.fits'
% int(csu.sim_id),
hdu=1)
cmb_elm = hp.read_alm(
'/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_lensed_scl_cmb_000_alm_mc_%04d.fits'
% int(csu.sim_id),
hdu=2)
cmb_blm = hp.read_alm(
'/project/projectdirs/cmb/data/generic/cmb/ffp10/mc/scalar/ffp10_lensed_scl_cmb_000_alm_mc_%04d.fits'
% int(csu.sim_id),
hdu=3)
# TODO what is a reasonable nside for this?
CMB = hp.alm2map([cmb_tlm, cmb_elm, cmb_blm], nsi)
io.save_data(CMB, io.fh.map_cmb_sc_path_name)
def test_alm_cut():
# Tests alm filtering for CMB kappa alms on low resolution pixels.
config = get_config()
config['nside'] = 16
m = xc.mappers.MapperP18CMBK(config)
m.get_signal_map()
alm_all, lmax = hp.read_alm(config['file_klm'], return_mmax=True)
alm_all = m.rot.rotate_alm(alm_all)
fl = np.ones(lmax + 1)
fl[3 * 16:] = 0
alm_cut = hp.almxfl(alm_all, fl, inplace=True)
assert np.all(np.real(m.klm - alm_cut) == 0.)
def denoise(mask_path,data_path,tmp_path):
mask=hp.read_map(mask_path)
klm=hp.read_alm(data_path)
tmp=np.loadtxt(tmp_path)
ell=np.array(tmp[:,0])
N=np.array(tmp[:,1])
C=np.array(tmp[:,2]-tmp[:,1])
nlm=hp.sphtfunc.almxfl(klm,N/(C+N))
klm=hp.sphtfunc.almxfl(klm,C/(C+N))
ell,m=hp.sphtfunc.Alm.getlm(lmax=LMAX)
ell+=1
ls=klm*2.0/np.sqrt(ell*(ell+1))
potential=klm*2.0/(ell*(ell+1))
kmap=hp.sphtfunc.alm2map(klm,nside)
nmap=hp.sphtfunc.alm2map(nlm,nside)
lsmap=hp.sphtfunc.alm2map(ls,nside)
potentialmap=hp.sphtfunc.alm2map(potential,nside)
kappa=hp.sphtfunc.alm2cl(klm,lmax=LMAX)
kappa_name="kappa_cl"
Cl_plot(kappa,kappa_name)
lensing=hp.sphtfunc.alm2cl(ls,lmax=LMAX)
lensing_name="lensing_cl"
Cl_plot(lensing,lensing_name)
potential=hp.sphtfunc.alm2cl(potential,lmax=LMAX)
potential_name="potential_cl"
Cl_plot(potential,potential_name)
dec,ra=np.rad2deg(hp.pix2ang(nside,range(hp.nside2npix(nside))))
dec=90.-dec
ra=ra[mask>0]
dec=dec[mask>0]
kmap=kmap[mask>0]
return ra,dec,kmap
plt.figure()
hp.mollview(kmap)
plt.savefig("/home/yhwu/pic/kappa.png",dpi=1000)
plt.clf()
hp.mollview(nmap)
plt.savefig("/home/yhwu/pic/noise.png",dpi=1000)
plt.clf()
hp.mollview(lsmap)
plt.savefig("/home/yhwu/pic/lensing.png",dpi=1000)
plt.clf()
hp.mollview(potentialmap)
plt.savefig("/home/yhwu/pic/potential.png",dpi=1000)
plt.clf()
def generate_gaus_map(self, readGmap=-1):
if (readGmap<0):
self.gausalm=hp.synalm(self.inputCls)
else:
# code assumes that self.mapsdir="maps50/"
self.gausalm=hp.read_alm(self.mapsdir+"gmap_"+str(readGmap)+".fits")
ns=0.965
C0N=(1.0-np.exp(-(ns-1)*self.efolds))/(ns-1)
C050=(1.0-np.exp(-(ns-1)*50))/(ns-1)
alm0r=np.sqrt(C0N/C050)
self.gausalm[0]=self.gausalm[0]*alm0r
self.gausmap=hp.alm2map(self.gausalm, nside=self.NSIDE) # includes the monopole bit
def get_signal_map(self):
if self.signal_map is None:
# Read alms
self.klm, lmax = hp.read_alm(self.config['file_klm'],
return_mmax=True)
if self.rot is not None:
self.klm = self.rot.rotate_alm(self.klm)
# Filter if lmax is too large
if lmax > 3 * self.nside - 1:
fl = np.ones(lmax + 1)
fl[3 * self.nside:] = 0
self.klm = hp.almxfl(self.klm, fl, inplace=True)
self.signal_map = np.array([hp.alm2map(self.klm, self.nside)])
return self.signal_map
def generate_gaus_map(self, readGmap=-1):
if (readGmap<0):
self.gausalm0=hp.synalm(self.inputCls)
else:
self.gausalm0=hp.read_alm(self.mapsdir+"gmap_"+str(readGmap)+".fits")
self.gausalm1=np.copy(self.gausalm0); self.gausalm1[0]=0.0
if (self.nodipole):
ndxfl=np.ones(len(self.inputCls))
ndxfl[1]=0.0
hp.almxfl(self.gausalm1, ndxfl, inplace=True)
hp.almxfl(self.gausalm0, ndxfl, inplace=True)
self.gausmap0=hp.alm2map(self.gausalm0, nside=self.NSIDE) # includes the monopole bit
self.gausmap1=hp.alm2map(self.gausalm1, nside=self.NSIDE) # does not include the monopole
def get_websky_sim(qid,shape,wcs,ra_pix_shift=None,components=['cmb','cib','tsz','ksz','ksz_patchy'],
bandpassed=True,no_act_color_correction=False,cmb_set=0):
# load cmb + ksz + tsz + isw alm
# get cfreq
# add nearest cib scaled to cfreq
gmix = lambda x: gen_mix(qid,x,bandpassed=bandpassed,bandpass_shifts=None,no_act_color_correction=no_act_color_correction)
owcs = wcs.copy()
if shift is not None: owcs.wcs.crpix -= np.asarray([ra_pix_shift,0])
lmax = 8192*3
asize = hp.Alm.getsize(lmax)
oalms = np.zeros((3,asize))
rpath = sints.dconfig['actsims']['websky_path'] + "/"
if 'cmb' in components:
ialm = hp.read_alm(rpath + "lensed_alm_seed%d.fits" % cmb_set,hdu=(1,2,3))
for i in range(3): oalms[i] = oalms[i] + maps.change_alm_lmax(ialm[i], lmax)
if 'tsz' in components:
tconversion = gmix('tSZ') # !!!
ialm = hp.read_alm(rpath + "alms/tsz_8192_alm.fits" )
oalms[0] = oalms[0] + ialm * tconversion
def get_sim_tlm(self, idx):
"""Returns an inverse-filtered temperature simulation.
Args:
idx: simulation index
Returns:
inverse-filtered temperature healpy alm array
"""
tfname = os.path.join(self.lib_dir, 'sim_%04d_tlm.fits'%idx if idx >= 0 else 'dat_tlm.fits')
if not os.path.exists(tfname):
tlm = self._apply_ivf_t(self.sim_lib.get_sim_tmap(idx), soltn=None if self.soltn_lib is None else self.soltn_lib.get_sim_tmliklm(idx))
if self.cache: hp.write_alm(tfname, tlm)
return tlm
return hp.read_alm(tfname)
def get_sim_qlm_mf(self, k, mc_sims, lmax=None):
"""Returns a QE mean-field estimate, by averaging QE estimates from a set simulations (caches the result).
Args:
k: quadratic estimator key
mc_sims: simulation indices to use for the estimate.
lmax: optionally reduces the lmax of the output healpy array.
"""
if lmax is None:
lmax = self.get_lmax_qlm(k)
assert lmax <= self.get_lmax_qlm(k)
if k in ['p_tp', 'x_tp']:
return (self.get_sim_qlm_mf('%stt' % k[0], mc_sims, lmax=lmax) +
self.get_sim_qlm_mf('%s_p' % k[0], mc_sims, lmax=lmax))
if k in ['p_te', 'p_tb', 'p_eb', 'x_te', 'x_tb', 'x_eb']:
return self.get_sim_qlm_mf(k[0] + k[2] + k[3], mc_sims, lmax=lmax) \
+ self.get_sim_qlm_mf(k[0] + k[3] + k[2], mc_sims, lmax=lmax)
if '_bh_' in k: # Bias-hardening
assert self.resplib is not None, 'resplib arg necessary for this'
kQE, ksource = k.split('_bh_')
assert len(ksource) == 1 and ksource + kQE[1:] in self.keys, (
ksource, kQE)
assert self.get_lmax_qlm(kQE) == self.get_lmax_qlm(
ksource + kQE[1:]), 'fix this (easy)'
lmax = self.get_lmax_qlm(kQE)
wL = self.resplib.get_response(kQE, ksource) * ut.cli(
self.resplib.get_response(ksource + kQE[1:], ksource))
ret = self.get_sim_qlm_mf(kQE, mc_sims, lmax=lmax)
return ret - hp.almxfl(
self.get_sim_qlm_mf(ksource + kQE[1:], mc_sims, lmax=lmax), wL)
assert k in self.keys_fund, (k, self.keys_fund)
fname = os.path.join(self.lib_dir,
'simMF_k1%s_%s.fits' % (k, ut.mchash(mc_sims)))
if not os.path.exists(fname):
this_mcs = np.unique(mc_sims)
MF = np.zeros(hp.Alm.getsize(lmax), dtype=complex)
if len(this_mcs) == 0: return MF
for i, idx in ut.enumerate_progress(this_mcs,
label='calculating %s MF' % k):
MF += self.get_sim_qlm(k, idx, lmax=lmax)
MF /= len(this_mcs)
_write_alm(fname, MF)
print("Cached ", fname)
return ut.alm_copy(hp.read_alm(fname), lmax=lmax)
def test_standalone_cmb():
alm_filename = get_pkg_data_filename(
"data/fullskyUnlensedUnabberatedCMB_alm_set00_00000.fits")
cmb_dir = os.path.dirname(alm_filename)
nside = 32
cmb_map = cmb.SOStandalonePrecomputedCMB(
num=0,
nside=nside,
cmb_dir=cmb_dir,
lensed=False,
aberrated=False,
input_reference_frequency=148 * u.GHz,
input_units="uK_RJ",
).get_emission(148 * u.GHz, fwhm=1e-5 * u.arcmin)
input_alm = hp.read_alm(alm_filename, (1, 2, 3))
expected_cmb_map = hp.alm2map(input_alm, nside=nside) << u.uK_RJ
assert cmb_map.shape[0] == 3
assert_quantity_allclose(expected_cmb_map, cmb_map)
def get_sim_tlm(self, idx):
fname = self.lib_dir + '/sim_%04d_tlm.fits' % idx
if not os.path.exists(fname):
tlm = self.unlcmbs.get_sim_tlm(idx)
dlm = self.get_sim_plm(idx)
lmaxd = hp.Alm.getlmax(dlm.size)
hp.almxfl(dlm,
np.sqrt(
np.arange(lmaxd + 1, dtype=float) *
np.arange(1, lmaxd + 2)),
inplace=True)
hp.write_alm(
fname,
lens.lens_tlm(tlm,
dlm,
nside=self.nside_lens,
lmaxout=self.lmax))
return hp.read_alm(fname)
def generate_gaus_map(self, readGmap=-1):
if (readGmap < 0):
self.gausalm0 = hp.synalm(self.inputCls)
else:
self.gausalm0 = hp.read_alm(self.mapsdir + "gmap_" +
str(readGmap) + ".fits")
self.gausalm1 = np.copy(self.gausalm0)
self.gausalm1[0] = 0.0
if (self.nodipole):
ndxfl = np.ones(len(self.inputCls))
ndxfl[1] = 0.0
hp.almxfl(self.gausalm1, ndxfl, inplace=True)
hp.almxfl(self.gausalm0, ndxfl, inplace=True)
self.gausmap0 = hp.alm2map(
self.gausalm0, nside=self.NSIDE) # includes the monopole bit
self.gausmap1 = hp.alm2map(
self.gausalm1, nside=self.NSIDE) # does not include the monopole
def compute_intensity_derivatives(self, fromalm=False):
"""
Compute derivatives of the input temperature map (healpix).
Not updated for dichroic for the moment.
Parameters
----------
fromalm : bool, optional
If True, loads alm file from disk instead of fourier
transform the input map. Automatically turns True if you input
alm files. False otherwise.
Examples
----------
>>> filename = 's4cmb/data/test_data_set_lensedCls.dat'
>>> hpmap = HealpixFitsMap(input_filename=filename, fwhm_in=3.5,
... nside_in=16, compute_derivatives=True, map_seed=489237)
>>> hasattr(hpmap, 'dIdp')
True
"""
if fromalm:
alm = hp.read_alm(self.input_filename[0])
else:
alm = hp.map2alm(self.I, self.lmax)
# lmax = hp.Alm.getlmax(alm.size)
if "T1" in self.derivatives_type:
junk, self.dIdt, self.dIdp = hp.alm2map_der1(
alm, self.nside_in, self.lmax)
else:
# computes first and second derivative as derivatives of spin-1
# transform of a scalar field with _1Elm=sqrt(l(l+1))Ilm _1Blm=0
l = np.arange(self.lmax + 1)
grad = np.sqrt(l * (l + 1))
curl = np.zeros_like(alm)
dervs = alm2map_spin_der1([hp.almxfl(alm, grad), curl],
self.nside_in, 1)
self.dIdt = dervs[0][0]
self.dIdp = dervs[0][1]
self.d2Id2t = dervs[1][0]
self.d2Id2p = dervs[2][1]
self.d2Idpdt = dervs[2][0]
def denoise(mask_path, data_path, tmp_path):
mask = hp.read_map(mask_path)
klm = hp.read_alm(data_path)
tmp = np.loadtxt(tmp_path)
ell = np.array(tmp[:, 0])
N = np.array(tmp[:, 1])
C = np.array(tmp[:, 2] - tmp[:, 1])
nlm = hp.sphtfunc.almxfl(klm, N / (C + N))
klm = hp.sphtfunc.almxfl(klm, C / (C + N))
ell, m = hp.sphtfunc.Alm.getlm(lmax=LMAX)
ell += 1
ls = klm * 2.0 / np.sqrt(ell * (ell + 1))
lss = klm * 2.0 / (ell * (ell + 1))
kmap = hp.sphtfunc.alm2map(klm, nside)
nmap = hp.sphtfunc.alm2map(nlm, nside)
lsmap = hp.sphtfunc.alm2map(ls, nside)
lssmap = hp.sphtfunc.alm2map(lss, nside)
kappa = hp.sphtfunc.alm2cl(klm, lmax=LMAX)
kappa_name = "kappa_cl"
#Cl_plot(kappa,kappa_name)
lensing = hp.sphtfunc.alm2cl(ls, lmax=LMAX)
lensing_name = "lensing_filtered_cl"
#Cl_plot(lensing,lensing_name)
plt.figure()
'''
hp.mollview(kmap)
plt.savefig("/home/yhwu/pic/kappa.png",dpi=1000)
plt.clf()
hp.mollview(nmap)
plt.savefig("/home/yhwu/pic/noise.png",dpi=1000)
plt.clf()
'''
hp.mollview(lsmap)
plt.savefig("/home/yhwu/pic/lensing.png", dpi=1000)
plt.clf()
hp.mollview(lssmap)
plt.savefig("/home/yhwu/pic/lss.png", dpi=1000)
plt.clf()
def FilterMap(pixmap, freq, mask=None, lmax=None, pixelwindow=False):
if mask is None:
mask = np.ones_like(pixmap)
else:
assert hp.isnpixok(mask.size)
Fl = GetFl(pixmap,freq, mask=mask, lmax=lmax)
alm_fname='alm_%s.fits'%freq
if not os.path.exists(alm_fname):
print "computing alms"
alm = hp.map2alm(pixmap, lmax=lmax)
hp.write_alm(alm_fname,alm)
else:
print "reading alms",alm_fname
alm = hp.read_alm(alm_fname)
if pixelwindow:
print "Correcting alms for pixelwindow"
pl=hp.pixwin(hp.npix2nside(pixmap.size))[:lmax+1]
else: pl=np.ones(len(Fl))
return hp.alm2map(hp.almxfl(alm, Fl/pl), hp.npix2nside(pixmap.size), lmax=lmax), Fl
def main():
'''
MPI Setup
'''
o_comm = MPI.COMM_WORLD
i_rank = o_comm.Get_rank() # current core number -- e.g., i in arange(i_size)
i_size = o_comm.Get_size() # number of cores assigned to run this program
o_status = MPI.Status()
i_work_tag = 0
i_die_tag = 1
'''
Loading and calculating power spectrum components
'''
# Get run parameters
s_fn_params = 'data/params.pkl'
(i_lmax, i_nside, s_fn_map, s_map_name, s_fn_mask, s_fn_mll, s_fn_beam,
s_fn_alphabeta, s_fn_cltt) = get_params(s_fn_params)
#s_fn_cltt = 'sims/cl_fnl_0.dat'
if (i_rank == 0):
s_fn_cl21_data = 'output/cl21_data.dat'
s_fn_cl21_data_no_mll = 'output/cl21_data_no_mll.dat'
#s_fn_cl21_data = 'output/cl21_ps_smica.dat'
#s_fn_cl21_data_no_mll = 'output/cl21_ps_smica_no_mll.dat'
f_t1 = time.time()
print ""
print "Run parameters:"
print "(Using %i cores)" % i_size
print "lmax: %i, nside: %i, map name: %s" % (i_lmax, i_nside, s_map_name)
print "beam: %s, alpha_beta: %s, cltt: %s" % (s_fn_beam, s_fn_alphabeta, s_fn_cltt)
print ""
print "Loading ell, r, dr, alpha, beta, cltt, and beam..."
na_mask = hp.read_map(s_fn_mask)
#s_fn_mll = 'output/na_mll_%i_lmax.npy' % i_lmax
s_fn_mll = 'output/na_mll_1499_lmax.npy'
na_mll = np.load(s_fn_mll)
na_mll_inv = np.linalg.inv(na_mll)
na_l, na_r, na_dr, na_alpha, na_beta = np.loadtxt(s_fn_alphabeta,
usecols=(0,1,2,3,4), unpack=True, skiprows=3)
na_l = np.unique(na_l)
na_r = np.unique(na_r)[::-1]
i_num_r = len(na_r)
try:
na_cltt = np.load(s_fn_cltt)
except:
na_cltt = np.loadtxt(s_fn_cltt)
na_bl = np.load(s_fn_beam)
na_alpha = na_alpha.reshape(len(na_l), i_num_r)
na_beta = na_beta.reshape(len(na_l), i_num_r)
na_dr = na_dr.reshape(len(na_l), i_num_r)
na_dr = na_dr[0]
i_num_ell = min(len(na_l), len(na_cltt), len(na_bl), i_lmax)
na_l = na_l[:i_num_ell]
na_cltt = na_cltt[:i_num_ell]
na_bl = na_bl[:i_num_ell]
na_alpha = na_alpha[:i_num_ell,:]
na_beta = na_beta[:i_num_ell,:]
if (i_rank == 0):
print "i_num_r: %i, i_num_ell: %i" % (i_num_r, i_num_ell)
# f_t2 = time.time()
if (i_rank == 0):
print ""
print "Calculating full skewness power spectrum..."
s_fn_alm = 'output/na_alm_data.fits'
#s_fn_alm = 'data/ps_sim/alm_ps_smica_ell_2000.fits'
na_alm = hp.read_alm(s_fn_alm)
na_alm = na_alm[:hp.Alm.getsize(i_num_ell)]
# f_t3 = time.time()
na_cl21_data = np.zeros(i_num_ell)
na_work = np.zeros(1, dtype='i')
na_result = np.zeros(i_num_ell, dtype='d')
# master loop
if (i_rank == 0):
# send initial jobs
for i_rank_out in range(1,i_size):
na_work = np.array([i_rank_out-1], dtype='i')
o_comm.Send([na_work, MPI.INT], dest=i_rank_out, tag=i_work_tag)
for i_r in range(i_size-1,i_num_r):
if (i_r % (i_num_r / 10) == 0):
print "Finished %i%% of jobs... (%.2f s)" % (i_r * 100 / i_num_r,
time.time() - f_t1)
na_work = np.array([i_r], dtype='i')
o_comm.Recv([na_result, MPI.DOUBLE], source=MPI.ANY_SOURCE,
status=o_status, tag=MPI.ANY_TAG)
#print "received results from core %i" % o_status.Get_source()
o_comm.Send([na_work,MPI.INT], dest=o_status.Get_source(),
tag=i_work_tag)
na_cl21_data += na_result
for i_rank_out in range(1,i_size):
o_comm.Recv([na_result, MPI.DOUBLE], source=MPI.ANY_SOURCE,
status=o_status, tag=MPI.ANY_TAG)
na_cl21_data += na_result
print "cl21_data = %.6f, na_result = %.6f" % (np.average(na_cl21_data), np.average(na_result))
o_comm.Send([np.array([9999], dtype='i'), MPI.INT],
dest=o_status.Get_source(), tag=i_die_tag)
#slave loop:
else:
while(1):
o_comm.Recv([na_work, MPI.INT], source=0, status=o_status,
tag=MPI.ANY_TAG)
if (o_status.Get_tag() == i_die_tag):
break
i_r = na_work[0]
#print "doing work for r = %i on core %i" % (i_r, i_rank)
na_Alm = hp.almxfl(na_alm, na_alpha[:,i_r] / na_cltt * na_bl)
na_Blm = hp.almxfl(na_alm, na_beta[:,i_r] / na_cltt * na_bl)
# print ("doing work for r=%i, alpha=(%.2f), beta=(%.2f)" %
# (int(na_r[i_r]), na_alpha[0,i_r], na_beta[0,i_r]))
# f_t4 = time.time()
na_An = hp.alm2map(na_Alm, nside=i_nside, fwhm=0.00145444104333,
verbose=False)
na_Bn = hp.alm2map(na_Blm, nside=i_nside, fwhm=0.00145444104333,
verbose=False)
# *REMBER TO MULTIPLY BY THE MASK!* -- already doing this in cltt.py...
na_An = na_An * na_mask
na_Bn = na_Bn * na_mask
# f_t5 = time.time()
#print "starting map2alm for r = %i on core %i" % (i_r, i_rank)
na_B2lm = hp.map2alm(na_Bn*na_Bn, lmax=i_num_ell)
na_ABlm = hp.map2alm(na_An*na_Bn, lmax=i_num_ell)
#print "finished map2alm for r = %i on core %i" % (i_r, i_rank)
# f_t6 = time.time()
na_clAB2 = hp.alm2cl(na_Alm, na_B2lm, lmax=i_num_ell)
na_clABB = hp.alm2cl(na_ABlm, na_Blm, lmax=i_num_ell)
#na_clAB2 = na_clAB2[:-1] # just doing this to make things fit...
#na_clABB = na_clABB[:-1] # just doing this to make things fit...
na_clAB2 = na_clAB2[1:]
na_clABB = na_clABB[1:]
#f_t7 = time.time()
na_result = np.zeros(i_num_ell, dtype='d')
na_result += (na_clAB2 + 2 * na_clABB) * na_r[i_r]**2. * na_dr[i_r]
print ("finished work for r=%i, avg(alpha)=%.2f, avg(beta)=%.2f, avg(result)=%.4g" %
(int(na_r[i_r]), np.average(na_alpha[:,i_r]),
np.average(na_beta[:,i_r]), np.average(na_result)))
#print "finished work for r = %i on core %i" % (i_r, i_rank)
o_comm.Send([na_result,MPI.DOUBLE], dest=0, tag=1)
# print "Load time: %.2f s" % (f_t2 - f_t1)
# print "synalm time: %.2f s" % (f_t3 - f_t2)
# print "almxfl time: %.2f s" % ((f_t4 - f_t3) / 2.)
# print "alm2map time: %.2f s" % ((f_t5 - f_t4) / 2.)
# print "map2alm time: %.2f s" % ((f_t6 - f_t5) / 2.)
# print "alm2cl time: %.2f s" % ((f_t7 - f_t6) / 2.)
f_t8 = time.time()
if (i_rank == 0):
print ""
print ("Saving power spectrum to %s (not mll corrected)"
% s_fn_cl21_data_no_mll)
np.savetxt(s_fn_cl21_data_no_mll, na_cl21_data)
print ""
print "Saving power spectrum to %s (mll corrected)" % s_fn_cl21_data
na_cl21_data = np.dot(na_mll_inv, na_cl21_data)
np.savetxt(s_fn_cl21_data, na_cl21_data)
# print "Finished in %.2f s" % (f_t8 - f_t1)
# # print "Load time: %.2f s" % (f_t2 - f_t1)
# # print "synalm time: %.2f s" % (f_t3 - f_t2)
# # print "almxfl time: %.2f s" % ((f_t4 - f_t3) / 2.)
# # print "alm2map time: %.2f s" % ((f_t5 - f_t4) / 2.)
# # print "map2alm time: %.2f s" % ((f_t6 - f_t5) / 2.)
# # print "alm2cl time: %.2f s" % ((f_t7 - f_t6) / 2.)
return
def main(argv):
ras,decs = getCatalogRADecsPlanck()
pixScale = 0.5
widthArc = 70.
width = widthArc/60.
Np = np.int(width/pixScale*60.+0.5)
saveRoot = "/astro/astronfs01/workarea/msyriac/SkyData/"
planckRoot = saveRoot+'cmb/'
planckMaskPath = planckRoot+'planck2015_mask.fits'
mask15 = hp.read_map(planckMaskPath,verbose=False)
saveRoot = "/astro/astronfs01/workarea/msyriac/SkyData/"
planckRoot = saveRoot+'cmb/'
pl15lm = hp.read_alm(planckRoot+'dat_klm.fits')
hpPlanckK = hp.sphtfunc.alm2map(pl15lm,2048,pol=False)
outN = argv[0]
tfact = 1.
if outN=='143':
p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/HFI_SkyMap_143_2048_R2.02_full.fits'
elif outN=='com':
p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/COM_CMB_IQU-commander-field-Int_2048_R2.00.fits'
elif outN=='217':
p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/HFI_SkyMap_217_2048_R2.02_full.fits'
elif outN=='wpr2':
p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/WPR2_CMB_muK.fits'
tfact = 1.e-6
else:
print 'invalid input'
sys.exit()
Npix = 12.*2048**2.
print mask15.sum()/Npix
hpPlanck = hp.read_map(p143Loc)
hpPlanckCopy = hpPlanck.copy()
hpPlanckCopy[mask15<0.5]=np.nan
print np.nanmean(hpPlanckCopy)
lim = np.nanstd(hpPlanckCopy*tfact)
print lim
#sys.exit()
stack = 0.
stackK = 0.
maxN = None
#maxN = 10
i=0
for ra,dec in zip(ras[:maxN],decs[:maxN]):
i+=1
print i,ra,dec
# ra = np.random.uniform(5.,350.)
# dec = np.random.uniform(-80.,10.)
raLeft = ra - width/2.
raRight = ra + width/2.
decLeft = dec - width/2.
decRight = dec + width/2.
fieldCoords = (raLeft,decLeft,raRight,decRight)
smap = lm.makeEmptyCEATemplateAdvanced(*fieldCoords)
smapK = lm.makeEmptyCEATemplateAdvanced(*fieldCoords)
smap.loadDataFromHealpixMap(hpPlanck,hpCoords="GALACTIC")
smapK.loadDataFromHealpixMap(hpPlanckK,hpCoords="GALACTIC")
stamp = smap.data.copy() * tfact
stamp = zoom(stamp,zoom=(float(Np)/stamp.shape[0],float(Np)/stamp.shape[1]))
stampK = smapK.data.copy()
stampK = zoom(stampK,zoom=(float(Np)/stampK.shape[0],float(Np)/stampK.shape[1]))
stack += stamp[:,:]
stackK += stampK[:,:]
pl = Plotter()
pl.plot2d(stack/i)#,lim=lim*3.)
pl.done("stack"+outN+"6.png")
pl = Plotter()
pl.plot2d(stackK/i)#,lim=lim*3.)
pl.done("stackK6.png")
def main(i_sim=1):
'''
MPI Setup
'''
o_comm = MPI.COMM_WORLD
i_rank = o_comm.Get_rank() # current core number -- e.g., i in arange(i_size)
i_size = o_comm.Get_size() # number of cores assigned to run this program
o_status = MPI.Status()
i_work_tag = 0
i_die_tag = 1
'''
Loading and calculating power spectrum components
'''
# Get run parameters
s_fn_params = 'data/params.pkl'
(i_lmax, i_nside, s_fn_map, s_map_name, s_fn_mask, s_fn_mll, s_fn_beam,
s_fn_alphabeta, s_fn_cltt) = get_params(s_fn_params)
#s_fn_cltt = ('data/fnl_sims/cl_fnl_0_sim_%04d.fits' % (i_sim,))
f_fnl = 1.0
if (i_rank == 0):
s_fn_cl21_data = ('data/cl21_fnl_sims/cl21_fnl_%i_sim_%04d.dat'
% (int(f_fnl), i_sim))
s_fn_cl21_data_no_mll = ('data/cl21_fnl_sims/cl21_fnl_%i_sim_%04d_no_mll.dat'
% (int(f_fnl), i_sim))
f_t1 = time.time()
print ""
print "Run parameters:"
print "(Using %i cores)" % i_size
print "lmax: %i, nside: %i, map name: %s" % (i_lmax, i_nside, s_map_name)
print "beam: %s, alpha_beta: %s, cltt: %s" % (s_fn_beam, s_fn_alphabeta, s_fn_cltt)
print ""
print "Loading ell, r, dr, alpha, beta, cltt, and beam..."
i_lmax = 1024
na_mask = hp.read_map(s_fn_mask)
s_fn_mll = 'output/na_mll_%i_lmax.npy' % i_lmax
na_mll = np.load(s_fn_mll)
na_mll_inv = np.linalg.inv(na_mll)
na_l, na_r, na_dr, na_alpha, na_beta = np.loadtxt(s_fn_alphabeta,
usecols=(0,1,2,3,4), unpack=True, skiprows=3)
na_l = np.unique(na_l)
na_r = np.unique(na_r)[::-1]
na_l = na_l[:i_lmax]
i_num_ell = len(na_l)
i_num_r = len(na_r)
if (i_rank == 0):
print "i_num_r: %i, i_num_ell: %i" % (i_num_r, i_num_ell)
# assuming number of r's is set correctly and number of ells isn't necessarily
# related to lmax, i_num_ell, etc.
i_num_ell_alpha_beta_r = len(na_alpha)/i_num_r
na_alpha = na_alpha.reshape(i_num_ell_alpha_beta_r, i_num_r)
na_beta = na_beta.reshape(i_num_ell_alpha_beta_r, i_num_r)
na_dr = na_dr.reshape(i_num_ell_alpha_beta_r, i_num_r)
na_dr = na_dr[0]
na_alpha = na_alpha[:i_num_ell,:]
na_beta = na_beta[:i_num_ell,:]
na_dr = na_dr[:i_num_ell]
try:
na_cltt = np.load(s_fn_cltt)
except:
na_cltt = np.loadtxt(s_fn_cltt)
na_cltt = na_cltt[:i_num_ell]
na_bl = np.load(s_fn_beam)
na_bl = na_bl[:i_num_ell]
# f_t2 = time.time()
if (i_rank == 0):
print ""
print "Calculating full skewness power spectrum..."
#na_alm = hp.synalm(na_cltt, lmax=i_num_ell, verbose=False)
s_fn_almg = ('data/fnl_sims/alm_l_%04d_v3.fits' % (i_sim,))
na_almg = hp.read_alm(s_fn_almg)
na_almg = na_almg[:hp.Alm.getsize(i_num_ell)]
s_fn_almng = ('data/fnl_sims/alm_nl_%04d_v3.fits' % (i_sim,))
na_almng = hp.read_alm(s_fn_almng)
na_almng = na_almng[:hp.Alm.getsize(i_num_ell)]
na_alm = na_almg + f_fnl * na_almng
# f_t3 = time.time()
na_cl21_data = np.zeros(i_num_ell)
na_work = np.zeros(1, dtype='i')
na_result = np.zeros(i_num_ell, dtype='d')
# if (i_rank == 0):
# print ("na_alm: %s, na_alpha: %s, na_beta: %s, na_cltt: %s, na_bl: %s" %
# (str(np.shape(na_alm)), str(np.shape(na_alpha)),
# str(np.shape(na_beta)), str(np.shape(na_cltt)),
# str(np.shape(na_bl)) ))
# else:
# print "core: %i" % i_rank
# print ("na_alm: %s, na_alpha: %s, na_beta: %s, na_cltt: %s, na_bl: %s" %
# (str(np.shape(na_alm)), str(np.shape(na_alpha)),
# str(np.shape(na_beta)), str(np.shape(na_cltt)),
# str(np.shape(na_bl)) ))
# master loop
if (i_rank == 0):
# send initial jobs
# print ("na_alm: %s, na_alpha: %s, na_beta: %s, na_cltt: %s, na_bl: %s" %
# (str(np.shape(na_alm)), str(np.shape(na_alpha)),
# str(np.shape(na_beta)), str(np.shape(na_cltt)),
# str(np.shape(na_bl)) ))
for i_rank_out in range(1,i_size):
na_work = np.array([i_rank_out-1], dtype='i')
o_comm.Send([na_work, MPI.INT], dest=i_rank_out, tag=i_work_tag)
for i_r in range(i_size-1,i_num_r):
if (i_r % (i_num_r / 10) == 0):
print "Finished %i%% of jobs... (%.2f s)" % (i_r * 100 / i_num_r,
time.time() - f_t1)
na_work = np.array([i_r], dtype='i')
o_comm.Recv([na_result, MPI.DOUBLE], source=MPI.ANY_SOURCE,
status=o_status, tag=MPI.ANY_TAG)
#print "received results from core %i" % o_status.Get_source()
o_comm.Send([na_work,MPI.INT], dest=o_status.Get_source(),
tag=i_work_tag)
na_cl21_data += na_result
for i_rank_out in range(1,i_size):
o_comm.Recv([na_result, MPI.DOUBLE], source=MPI.ANY_SOURCE,
status=o_status, tag=MPI.ANY_TAG)
na_cl21_data += na_result
print "cl21 so far..."
print na_cl21_data[:10], na_cl21_data[10:]
o_comm.Send([np.array([9999], dtype='i'), MPI.INT],
dest=o_status.Get_source(), tag=i_die_tag)
#slave loop:
else:
while(1):
o_comm.Recv([na_work, MPI.INT], source=0, status=o_status,
tag=MPI.ANY_TAG)
if (o_status.Get_tag() == i_die_tag):
break
i_r = na_work[0]
#print "doing work for r = %i on core %i" % (i_r, i_rank)
# print ("na_alm: %s, na_alpha: %s, na_beta: %s, na_cltt: %s, na_bl: %s" %
# (str(np.shape(na_alm)), str(np.shape(na_alpha)),
# str(np.shape(na_beta)), str(np.shape(na_cltt)),
# str(np.shape(na_bl)) ))
na_Alm = hp.almxfl(na_alm, np.nan_to_num(na_alpha[:,i_r] / na_cltt) * na_bl)
na_Blm = hp.almxfl(na_alm, np.nan_to_num(na_beta[:,i_r] / na_cltt) * na_bl)
# f_t4 = time.time()
na_An = hp.alm2map(na_Alm, nside=i_nside, fwhm=0.00145444104333,
verbose=False)
na_Bn = hp.alm2map(na_Blm, nside=i_nside, fwhm=0.00145444104333,
verbose=False)
# *REMBER TO MULTIPLY BY THE MASK!*
na_An = na_An * na_mask
na_Bn = na_Bn * na_mask
# f_t5 = time.time()
#print "starting map2alm for r = %i on core %i" % (i_r, i_rank)
na_B2lm = hp.map2alm(na_Bn*na_Bn, lmax=i_num_ell)
na_ABlm = hp.map2alm(na_An*na_Bn, lmax=i_num_ell)
#print "finished map2alm for r = %i on core %i" % (i_r, i_rank)
# f_t6 = time.time()
na_clAB2 = hp.alm2cl(na_Alm, na_B2lm, lmax=i_num_ell)
na_clABB = hp.alm2cl(na_ABlm, na_Blm, lmax=i_num_ell)
na_clAB2 = na_clAB2[1:]
na_clABB = na_clABB[1:]
#f_t7 = time.time()
# print ("na_clAB2: %s, na_clABB: %s, na_r: %s, na_dr: %s" %
# (str(np.shape(na_clAB2)), str(np.shape(na_clABB)),
# str(np.shape(na_r)), str(np.shape(na_dr)) ))
na_result = np.zeros(i_num_ell, dtype='d')
na_result += (na_clAB2 + 2 * na_clABB) * na_r[i_r]**2. * na_dr[i_r]
#print "finished work for r = %i on core %i" % (i_r, i_rank)
o_comm.Send([na_result,MPI.DOUBLE], dest=0, tag=1)
# print "Load time: %.2f s" % (f_t2 - f_t1)
# print "synalm time: %.2f s" % (f_t3 - f_t2)
# print "almxfl time: %.2f s" % ((f_t4 - f_t3) / 2.)
# print "alm2map time: %.2f s" % ((f_t5 - f_t4) / 2.)
# print "map2alm time: %.2f s" % ((f_t6 - f_t5) / 2.)
# print "alm2cl time: %.2f s" % ((f_t7 - f_t6) / 2.)
f_t8 = time.time()
if (i_rank == 0):
print ""
print ("Saving power spectrum to %s (not mll corrected)"
% s_fn_cl21_data_no_mll)
np.savetxt(s_fn_cl21_data_no_mll, na_cl21_data)
print ""
print "Saving power spectrum to %s (mll corrected)" % s_fn_cl21_data
na_cl21_data = np.dot(na_mll_inv, na_cl21_data)
np.savetxt(s_fn_cl21_data, na_cl21_data)
# print "Finished in %.2f s" % (f_t8 - f_t1)
# # print "Load time: %.2f s" % (f_t2 - f_t1)
# # print "synalm time: %.2f s" % (f_t3 - f_t2)
# # print "almxfl time: %.2f s" % ((f_t4 - f_t3) / 2.)
# # print "alm2map time: %.2f s" % ((f_t5 - f_t4) / 2.)
# # print "map2alm time: %.2f s" % ((f_t6 - f_t5) / 2.)
# # print "alm2cl time: %.2f s" % ((f_t7 - f_t6) / 2.)
return
'''
make_alms_with_fnl.py
Create alms using the Elsner maps (http://gavo.mpe.mpg.de/pub/Elsner/) for
alm_G and alm_NG to create:
alm = alm_G + fnl * alm_NG
where the input parameter to this program is fnl.
'''
import healpy as hp
import numpy as np
nsims = 1000
fnl = 0
for i in range(1,nsims+1):
fn_alm = 'alm_fnl_%i_sim_%04d.fits' % (fnl, i)
fn_cl = 'cl_fnl_%i_sim_%04d.fits' % (fnl, i)
print 'making %s...' % fn_alm
fn_alm_l = 'alm_l_%04d_v3.fits' % (i,)
fn_alm_nl = 'alm_nl_%04d_v3.fits' % (i,)
alm_g = hp.read_alm(fn_alm_l)
alm_ng = hp.read_alm(fn_alm_nl)
alm = alm_g + fnl * alm_ng
hp.write_alm(fn_alm, alm)
print 'making %s...' % fn_cl
cl = hp.alm2cl(alm)
np.savetxt(fn_cl, cl)
def main(run_type='data', nsim=0, fnl=0):
'''
MPI Setup
'''
o_comm = MPI.COMM_WORLD
i_rank = o_comm.Get_rank() # current core number -- e.g., i in arange(i_size)
i_size = o_comm.Get_size() # number of cores assigned to run this program
o_status = MPI.Status()
i_work_tag = 0
i_die_tag = 1
'''
Loading and calculating power spectrum components
'''
if (run_type == 'fnl'):
nl = 1024
else:
nl = 1499
if (run_type == 'data'):
fn_map = h._fn_map
elif (run_type == 'sim'):
fn_map = 'output/map_sim_%i.fits' % nsim
elif (run_type == 'fnl'):
#print "fnl value: %i" % fnl
fn_map = 'data/fnl_sims/map_fnl_%i_sim_%i.fits' % (int(fnl), nsim)
# (1) read map (either map_data or map_sim), mask, mll, and create mll_inv;
map_in = hp.read_map(fn_map)
mask = hp.read_map(h._fn_mask)
if (run_type == 'fnl'):
mask = 1.
fn_mll = 'output/na_mll_%i_lmax.npy' % nl
mll = np.load(fn_mll)
if (run_type == 'fnl'):
mll = np.identity(nl)
mll_inv = np.linalg.inv(mll)
nside = hp.get_nside(map_in)
if (i_rank == 0):
if (run_type == 'data'):
fn_cl21 = 'output/cl21_data.dat'
fn_cl21_no_mll = 'output/cl21_data_no_mll.dat'
elif (run_type == 'sim'):
fn_cl21 = 'output/cl21_sim_%i.dat' % nsim
fn_cl21_no_mll = 'output/cl21_no_mll_%i.dat' % nsim
elif (run_type == 'fnl'):
fn_cl21 = 'output/cl21_fnl_%i_sim_%i.dat' % (int(fnl), nsim)
fn_cl21_no_mll = 'output/cl21_fnl_%i_sim_%i_no_mll.dat' % (int(fnl), nsim)
f_t1 = time.time()
print ""
print "Run parameters:"
print "(Using %i cores)" % i_size
print "nl: %i, nside: %i, map: %s" % (nl, nside, fn_map)
print "beam: %s, alpha_beta: %s, cltt: %s" % (h._fn_beam, h._fn_alphabeta, h._fn_cltt)
print ""
print "Loading ell, r, dr, alpha, beta, cltt, and beam..."
# (2) normalize, remove mono-/dipole, and mask map to create map_masked;
map_in /= (1e6 * 2.7)
map_in = hp.remove_dipole(map_in)
map_masked = map_in * mask
# (3) create alm_masked (map2alm on map_masked), cltt_masked (anafast on
# map_masked), and cltt_corrected (dot cltt_masked with mll_inv)
if (run_type == 'data' or run_type == 'sim'):
alm_masked = hp.map2alm(map_masked)
elif (run_type == 'fnl'):
fn_almg = ('data/fnl_sims/alm_l_%04d_v3.fits' % (nsim,))
almg = hp.read_alm(fn_almg)
fn_almng = ('data/fnl_sims/alm_nl_%04d_v3.fits' % (nsim,))
almng = hp.read_alm(fn_almng)
alm = almg + fnl * almng
alm_masked = alm
cltt_masked = hp.anafast(map_masked)
cltt_masked = cltt_masked[:nl]
cltt_corrected = np.dot(mll_inv, cltt_masked)
# stuff with alpha, beta, r, dr, and beam
l, r, dr, alpha, beta = np.loadtxt(h._fn_alphabeta,
usecols=(0,1,2,3,4), unpack=True, skiprows=3)
l = np.unique(l)
r = np.unique(r)[::-1]
nr = len(r)
if (run_type == 'data' or run_type == 'sim'):
cltt_denom = np.load('output/cltt_theory.npy') #replace with 'output/na_cltt.npy'
cltt_denom = cltt_denom[:nl]
elif (run_type == 'fnl'):
cltt_denom = np.loadtxt('joe/cl_wmap5_bao_sn.dat', usecols=(1,), unpack=True)
alpha = alpha.reshape(len(l), nr)
beta = beta.reshape(len(l), nr)
dr = dr.reshape(len(l), nr)
dr = dr[0]
if (run_type != 'fnl'):
beam = np.load(h._fn_beam)
else:
#beam = np.ones(len(cltt_denom))
beam = np.load(h._fn_beam)
noise = np.zeros(len(cltt_denom))
nlm = hp.synalm(noise, lmax=nl)
####### TEMPORARY -- change beam #######
#beam = np.ones(len(cltt_denom))
#noise = np.zeros(len(cltt_denom))
#nlm = hp.synalm(noise, lmax=nl)
########################################
l = l[:nl]
beam = beam[:nl]
alpha = alpha[:nl,:]
beta = beta[:nl,:]
if (i_rank == 0):
print "nr: %i, nl: %i" % (nr, nl)
f_t2 = time.time()
if (i_rank == 0):
print ""
print "Time to create alms from maps: %.2f s" % (f_t2 - f_t1)
print "Calculating full skewness power spectrum..."
cl21 = np.zeros(nl)
work = np.zeros(1, dtype='i')
result = np.zeros(nl, dtype='d')
# master loop
if (i_rank == 0):
# send initial jobs
for i_rank_out in range(1,i_size):
work = np.array([i_rank_out-1], dtype='i')
o_comm.Send([work, MPI.INT], dest=i_rank_out, tag=i_work_tag)
for i_r in range(i_size-1,nr):
if (i_r % (nr / 10) == 0):
print "Finished %i%% of jobs... (%.2f s)" % (i_r * 100 / nr,
time.time() - f_t2)
work = np.array([i_r], dtype='i')
o_comm.Recv([result, MPI.DOUBLE], source=MPI.ANY_SOURCE,
status=o_status, tag=MPI.ANY_TAG)
#print "received results from core %i" % o_status.Get_source()
o_comm.Send([work,MPI.INT], dest=o_status.Get_source(),
tag=i_work_tag)
cl21 += result
for i_rank_out in range(1,i_size):
o_comm.Recv([result, MPI.DOUBLE], source=MPI.ANY_SOURCE,
status=o_status, tag=MPI.ANY_TAG)
cl21 += result
print "cl21 = %.6f, result = %.6f" % (np.average(cl21), np.average(result))
o_comm.Send([np.array([9999], dtype='i'), MPI.INT],
dest=o_status.Get_source(), tag=i_die_tag)
#slave loop:
else:
while(1):
o_comm.Recv([work, MPI.INT], source=0, status=o_status,
tag=MPI.ANY_TAG)
if (o_status.Get_tag() == i_die_tag):
break
i_r = work[0]
#print ("i_r: %i" % i_r)
#print ("alm_masked: ", alm_masked)
#print ("cltt_denom: ", cltt_denom)
#print ("beam: ", beam)
#print ("mask: ", mask)
#print ("fn_map: ", fn_map)
# create Alm, Blm (almxfl with alm_masked and beta / cltt_denom
# * beam, etc.)
Alm = np.zeros(alm_masked.shape[0],complex)
Blm = np.zeros(alm_masked.shape[0],complex)
clAB2 = np.zeros(nl+1)
clABB = np.zeros(nl+1)
#Alm = hp.almxfl(alm_masked, alpha[:,i_r] / cltt_denom * beam)
#Blm = hp.almxfl(alm_masked, beta[:,i_r] / cltt_denom * beam)
#for li in xrange(2,nl):
# I = hp.Alm.getidx(nl,li,np.arange(min(nl,li)+1))
# Alm[I]=alpha[li-2][i_r]*(alm_masked[I]*beam[li]+nlm[I])/(cltt_denom[li]*beam[li]**2+noise[li])
# Blm[I]=beta[li-2][i_r]*(alm_masked[I]*beam[li]+nlm[I])/(cltt_denom[li]*beam[li]**2+noise[li])
if (run_type == 'fnl'):
for li in xrange(2,nl):
I = hp.Alm.getidx(nl,li,np.arange(min(nl,li)+1))
Alm[I]=alpha[li-2][i_r]*(alm_masked[I]*beam[li]+nlm[I])/(cltt_denom[li]*beam[li]**2+noise[li])
Blm[I]=beta[li-2][i_r]*(alm_masked[I]*beam[li]+nlm[I])/(cltt_denom[li]*beam[li]**2+noise[li])
else:
for li in xrange(2,nl):
I = hp.Alm.getidx(nl,li,np.arange(min(nl,li)+1))
Alm[I]=alpha[li-2][i_r]*(alm_masked[I])/cltt_denom[li]*beam[li]
Blm[I]=beta[li-2][i_r]*(alm_masked[I])/cltt_denom[li]*beam[li]
############################# DEBUG ################################
if i_r == 0:
cltt_Alm = hp.alm2cl(Alm)
cltt_Blm = hp.alm2cl(Blm)
np.savetxt('debug2/cltt_%s_Alm.dat' % run_type, cltt_Alm)
np.savetxt('debug2/cltt_%s_Blm.dat' % run_type, cltt_Blm)
####################################################################
#An = hp.alm2map(Alm, nside=nside, fwhm=0.00145444104333,
# verbose=False)
#Bn = hp.alm2map(Blm, nside=nside, fwhm=0.00145444104333,
# verbose=False)
An = hp.alm2map(Alm, nside=nside)
Bn = hp.alm2map(Blm, nside=nside)
############################# DEBUG ################################
if i_r == 0:
cltt_An = hp.anafast(An)
cltt_Bn = hp.anafast(Bn)
np.savetxt('debug2/cltt_%s_An.dat' % run_type, cltt_An)
np.savetxt('debug2/cltt_%s_Bn.dat' % run_type, cltt_Bn)
####################################################################
An = An * mask
Bn = Bn * mask
############################# DEBUG ################################
#if i_r == 0:
# print "saving alpha, beta for %i" % i_r
# np.savetxt('debug2/alpha_ir_%i' % i_r, alpha[:,i_r])
# np.savetxt('debug2/beta_ir_%i' % i_r, beta[:,i_r])
# print "(An * Bn)[:10] == An[:10] * Bn[:10]:", (An * Bn)[:10] == An[:10] * Bn[:10]
####################################################################
B2lm = hp.map2alm(Bn*Bn, lmax=nl)
ABlm = hp.map2alm(An*Bn, lmax=nl)
############################# DEBUG ################################
if i_r == 0:
cltt_B2lm = hp.alm2cl(B2lm)
cltt_ABlm = hp.alm2cl(ABlm)
np.savetxt('debug2/cltt_%s_B2lm.dat' % run_type, cltt_B2lm)
np.savetxt('debug2/cltt_%s_ABlm.dat' % run_type, cltt_ABlm)
####################################################################
#clAB2 = hp.alm2cl(Alm, B2lm, lmax=nl)
#clABB = hp.alm2cl(ABlm, Blm, lmax=nl)
for li in xrange(2,nl+1):
I = hp.Alm.getidx(nl,li,np.arange(min(nl,li)+1))
clAB2[li] = (Alm[I[0]]*B2lm[I[0]].conj()
+2.*sum(Alm[I[1:]]*B2lm[I[1:]].conj()))/(2.0*li+1.0)
clABB[li] = (Blm[I[0]]*ABlm[I[0]].conj()
+2.*sum(Blm[I[1:]]*ABlm[I[1:]].conj()))/(2.0*li+1.0)
############################# DEBUG ################################
if i_r == 0:
np.savetxt('debug2/clAB2_%s.dat' % run_type, clAB2)
np.savetxt('debug2/clABB_%s.dat' % run_type, clABB)
####################################################################
clAB2 = clAB2[1:]
clABB = clABB[1:]
result = np.zeros(nl, dtype='d')
result += (clAB2 + 2 * clABB) * r[i_r]**2. * dr[i_r]
############################# DEBUG ################################
np.savetxt('debug2/cl21_%s.dat' % run_type, result)
####################################################################
print ("finished work for r=%i, dr=%.2f, avg(alpha)=%.2f, avg(beta)=%.2f, avg(result)=%.4g" %
(int(r[i_r]), dr[i_r], np.average(alpha[:,i_r]),
np.average(beta[:,i_r]), np.average(result)))
############################# DEBUG ################################
#if i_r == 0:
# print "finished debug -- goodbye!"
# exit()
####################################################################
o_comm.Send([result,MPI.DOUBLE], dest=0, tag=1)
f_t8 = time.time()
if (i_rank == 0):
print ""
print ("Saving power spectrum to %s (not mll corrected)"
% fn_cl21_no_mll)
np.savetxt(fn_cl21_no_mll, cl21)
print ""
print "Saving power spectrum to %s (mll corrected)" % fn_cl21
cl21 = np.dot(mll_inv, cl21)
np.savetxt(fn_cl21, cl21)
return
'''
desredmapper_clusters_sptpol_field_file = 'data/sanjay_maps_201705xx/final_maps/20170605_downsample_x2_TP/map_150.pkl.gz_cutouts_150ghz_no_downsamplingredmapper_clusters'
dic = pickle.load(gzip.open(desredmapper_clusters_sptpol_field_file, 'rb'))['cutouts']
cat = np.asarray(dic.keys())
ra, dec, z = cat[:,0], cat[:,1], cat[:,2]
cutout_dic_name = 'data/planck/redmapper_DES_sptpol_field.pkl.gz'
'''
desredmapper_clusters_file = 'data/redmapper/y1a1_gold_1.0.3-d10-mof-001b_run_redmapper_v6.4.16_lgt20_desformat_catalog_extracted.txt'
ra, dec, z = np.loadtxt(desredmapper_clusters_file, usecols = [2,3,6], unpack = True)
cutout_dic_name = 'data/planck/redmapper_DES_full_field.pkl.gz'
#sys.exit()
if not smica:
print("...loading PlanckLens alms...")
kappa_lm = hp.read_alm(planck_alms)
print("...done...")
print("...converting PlanckLens alms to map...")
kappa = hp.alm2map(kappa_lm, nside)
print("...done...")
else:
print("...reading SMICA map now: %s..." %(smica_map_file))
kappa = hp.read_map(smica_map_file, field=0, verbose=0) #not kappa but SMICA: just T now.
print("...done...")
print("...loading PlanckLens mask...")
mask = hp.read_map(planck_mask, verbose=0)
print("...done...")
b = b.reshape(1499, nR)
dR = dR.reshape(1499, nR)
dR = dR[0]
###################################
# Put alpha and beta in a format condusive for r dependance
# a = a.reshape(500,1999)
# b = b.reshape(500,1999)
# R = R.reshape(500,1999)
# Initialize arrays
N = 0
# Read In alms and cls
alm = hp.read_alm("Maps/alm_l_" + str(N) + ".fits")
flm = hp.read_alm("Maps/alm_nl_" + str(N) + ".fits")
Alm = zeros(alm.shape[0], complex)
Blm = zeros(alm.shape[0], complex)
CAB2l = zeros((a.shape[0], LMAX + 1))
CABBl = zeros((a.shape[0], LMAX + 1))
clab2 = zeros(CAB2l.shape[1])
clabb = zeros(CAB2l.shape[1])
############## DEBUG ##############
alm_data = alm + fnl * flm
Alm_jon = zeros(alm_data.shape[0], complex)
Blm_jon = zeros(alm_data.shape[0], complex)
clAB2_jon = zeros(nl + 1)
clABB_jon = zeros(nl + 1)
###################################
a = a.reshape(500,1999)
b = b.reshape(500,1999)
R = R.reshape(500,1999)
# Initialize arrays
#for N in arange(int(sys.argv[1]),500,int(sys.argv[2])):
for N in xrange(0,10):
print '#########################################################'
print ""
print N
print ""
print '#########################################################'
#Read In alms and cls
alm = hp.read_alm('Maps/alm_l_'+str(N)+'.fits')
flm = hp.read_alm('Maps/alm_nl_'+str(N)+'.fits')
Alm = zeros(hp.Alm.getsize(LMAX),complex)
#Alm = zeros(alm.shape[0],complex)
Blm = zeros(hp.Alm.getsize(LMAX),complex)
#Blm = zeros(alm.shape[0],complex)
CAB2l = zeros((a.shape[0],LMAX+1))
CABBl = zeros((a.shape[0],LMAX+1))
clab2 = zeros(CAB2l.shape[1])
clabb = zeros(CAB2l.shape[1])
for r in xrange(a.shape[0]):
print r
for l in xrange(2,LMAX):
I = hp.Alm.getidx(LMAX,l,arange(min(LMAX,l)+1))
Alm[I]=a[r][l-2]*(alm[I]+fnl*flm[I])/cl[l]
