def calculate(self):
"""
calculate various properties of the gaussian, fnl, gnl maps i.e. compute
* Ais
* As
* Cls
* dipoles using remove_dipole
"""
inpCls=self.inputCls[:self.lmax+1]
if (self.gausmap!=None):
self.gausCls=hp.alm2cl(self.gausalm)[0:self.lmax+1]
self.gausA0=get_A0(self.gausCls[1:], inpCls[1:])
self.gausAi=Ais(self.gausmap, self.lmax); self.gausA=AistoA(self.gausAi)
self.gausmp=hp.remove_monopole(self.gausmap, fitval=True)[1]
self.gausdipole=get_dipole(self.gausmap)
if (self.gnlmaps!=None):
self.gnlCls=[]; self.gnlA0=[]; self.gnlAi=[]
self.gnlmp=[]; self.gnldipole=[]; self.gnlA=[]
for i in range(self.Ngnls):
self.gnlCls.append(hp.anafast(self.gnlmaps[i], nspec=self.lmax))
self.gnlA0.append(get_A0(self.gnlCls[i][1:], inpCls[1:]))
self.gnlAi.append(Ais(self.gnlmaps[i], self.lmax)); self.gnlA.append(AistoA(self.gnlAi[i]))
self.gnlmp.append(hp.remove_monopole(self.gnlmaps[i], fitval=True)[1])
self.gnldipole.append(get_dipole(self.gnlmaps[i]))
def test_anafast_xspectra(self):
cl = hp.anafast(hp.remove_monopole(self.map1[0]),
hp.remove_monopole(self.map2[0]),
lmax=self.lmax)
self.assertEqual(len(cl), self.lmax + 1)
clx = hp.read_cl(
os.path.join(
self.path, 'data',
'cl_wmap_band_iqumap_r9_7yr_WVxspec_v4_udgraded32_II_lmax64_rmmono_3iter.fits'
))
np.testing.assert_array_almost_equal(cl, clx, decimal=8)
def test_anafast_xspectra(self):
cl = hp.anafast(
hp.remove_monopole(self.map1[0]),
hp.remove_monopole(self.map2[0]),
lmax=self.lmax,
)
self.assertEqual(len(cl), self.lmax + 1)
clx = hp.read_cl(
os.path.join(
self.path,
"data",
"cl_wmap_band_iqumap_r9_7yr_WVxspec_v4_udgraded32_II_lmax64_rmmono_3iter.fits",
)
)
np.testing.assert_array_almost_equal(cl, clx, decimal=8)
def test_anafast_iqu(self):
self.map1[0] = hp.remove_monopole(self.map1[0])
cl = hp.anafast(self.map1, lmax=self.lmax)
self.assertEqual(len(cl[0]), 65)
self.assertEqual(len(cl), 6)
for i in range(6):
np.testing.assert_array_almost_equal(cl[i], self.cliqu[i], decimal=8)
def test_anafast_iqu(self):
self.map1[0] = hp.remove_monopole(self.map1[0])
cl = hp.anafast(self.map1, lmax=self.lmax)
self.assertEqual(len(cl[0]), 65)
self.assertEqual(len(cl), 6)
for i in range(6):
np.testing.assert_array_almost_equal(cl[i], self.cliqu[i], decimal=8)
def test_k2g2k_rand():
"""Test that transformation of k->g->k recovers the input convergence map."""
nside = 16
npix = hp.nside2npix(nside)
lmax = 32
k = np.random.standard_normal(npix)
k = hp.smoothing(k, lmax=lmax, verbose=False)
k = hp.remove_monopole(k)
k = hp.remove_dipole(k)
g1, g2 = transformations.conv2shear(k, lmax)
k_recov = transformations.shear2conv(g1, g2, lmax)
np.testing.assert_almost_equal(k, k_recov, decimal=3)
def read_and_diff_files_fast_hitweight(f1,f2,fh1,fh2,fhfull,nside=256,tmask=None,return_map=False,remove_monopole=True):
#assume tmask is already degraded, remove_monopole=True: remove from differences before anafast
#monopole is removed from I,Q U maps after masking
mm1=hp.read_map(f1,[0,1,2],verbose=False)
mm2=hp.read_map(f2,[0,1,2],verbose=False)
h1=hp.read_map(fh1,[3],verbose=False)
h2=hp.read_map(fh2,[3],verbose=False)
hit_full=hp.read_map(fhfull,[3],verbose=False)
nsh=hp.npix2nside(len(h1))
if nsh != nside:
h1=hp.ud_grade(h1,nside_out=nside,power=-2)
h2=hp.ud_grade(h2,nside_out=nside,power=-2)
hit_full=hp.ud_grade(hit_full,nside_out=nside,power=-2)
mmm1=[]
mmm2=[]
for m1,m2 in zip(mm1,mm2):
m1=hp.ud_grade(hp.ma(m1),nside_out=nside)
m2=hp.ud_grade(hp.ma(m2),nside_out=nside)
tmask=m1.mask | m2.mask | tmask
mmm1.append(m1)
mmm2.append(m2)
whit = np.sqrt(hit_full*(1./h1+1./h2)) # m1[3] and m2[3] are the hit counts of the two maps to be nulled
diff=[]
for m1,m2 in zip(mmm1,mmm2):
d=(m1-m2)/whit
d.mask=tmask
if remove_monopole:
d=hp.remove_monopole(d)
diff.append(d)
skyfrac=1-float(tmask.sum())/len(tmask)
cldata=hp.anafast(diff)
cldata_out=[]
for cl in cldata:
cldata_out.append(cl/skyfrac)
if return_map is False:
return cldata_out
if return_map is True:
return cldata_out,diff
def calculate(self):
"""
calculate various properties of the gaussian, fnl, gnl maps i.e. compute
* Ais
* As
* Cls
* dipoles using remove_dipole
"""
inpCls = self.inputCls[:self.lmax + 1]
if (self.gausmap0 != None):
self.gausCls0 = hp.alm2cl(self.gausalm0)[0:self.lmax + 1]
self.gausCls1 = hp.alm2cl(self.gausalm1)[0:self.lmax + 1]
self.gausA0 = get_A0(self.gausCls0[1:], inpCls[1:])
self.gausAi = Ais(self.gausmap1, self.lmax)
self.gausA = AistoA(self.gausAi)
self.gausAi2 = Ais(self.gausmap0, self.lmax)
self.gausA2 = AistoA(self.gausAi2)
self.gausmp = hp.remove_monopole(self.gausmap0, fitval=True)[1]
self.gausdipole = get_dipole(self.gausmap1)
if (self.fnlmaps1 != None):
self.fnlCls0 = []
self.fnlCls1 = []
self.fnlA0 = []
self.fnlAi = []
self.fnlAi2 = []
self.fnlmp = []
self.fnldipole = []
self.fnlA = []
self.fnlA2 = []
for i in range(self.Nfnls):
#self.fnlCls0.append(hp.anafast(self.fnlmaps0[i], nspec=self.lmax))
self.fnlCls1.append(
hp.anafast(self.fnlmaps1[i], nspec=self.lmax))
#self.fnlA0.append(get_A0(self.fnlCls0[i][1:], inpCls[1:]))
self.fnlAi.append(Ais(self.fnlmaps1[i], self.lmax))
self.fnlA.append(AistoA(self.fnlAi[i]))
#self.fnlAi2.append(Ais(self.fnlmaps0[i], self.lmax)); self.fnlA2.append(AistoA(self.fnlAi2[i]))
#self.fnlmp.append(hp.remove_monopole(self.fnlmaps0[i], fitval=True)[1])
self.fnldipole.append(get_dipole(self.fnlmaps1[i]))
def spice(map1,
map2=None,
window=None,
mask=None,
window2=None,
mask2=None,
apodizesigma=0.0,
apodizetype=0,
thetamax=180.0,
decouple=False,
returnxi=False,
remove_monopole=False,
remove_dipole=False):
'''This is an implementation of the PolSpice algorithm in Python.
Parameters
----------
map1 : str or list
Input filename to load or list of 3 Healpix maps (I, Q, U)
map2 : str or list, optional
Input filename to load or list of 3 Healpix maps (I, Q, U)
window : str or numpy.ndarray, optional
Filename or array giving the weighted window to use.
mask : str or numpy.ndarray, optional
Filename or array giving the mask to use
window2 : str or numpy.ndarray, optional
Filename or array giving the weighted window to use for
the second map. If not input, the same window is used as
for the first map.
mask2 : str or numpy.ndarray, optional
Filename or array giving the mask to use for the second
map. If not input, the same window is used as for the
first map.
apodizesigma : float
Scale factor of the correlation function apodization (degrees)
apodizetype : int
Type of apodization. 0 is a Gaussian window. 1 is a cosine window
thetamax : float
maximum value of theta used in the integrals to calculate the
power spectra from the correlation functions.
decouple : bool
whether to compute the decoupled correlation functions
returnxi : bool
whether or not to return the correlation functions as an additional
output of the function
remove_monopole : bool
whether or not to remove the monopole from the maps before analyzing
them
remove_dipole : bool
whether or not to remove the dipole from the maps before analyzing
them
Returns
-------
cls : numpy.ndarray
An array containing the power spectra of the maps. TT, EE, BB, TE, EB, TB
xi : numpy.ndarray, optional
An array containing the real space correlation functions.
Notes
-----
If neither a window nor a mask are input, the functionality will
be similar to anafast.
'''
#If input is a string assume it is a filename
if isinstance(map1, str):
try:
map1 = H.read_map(map1, field=(0, 1, 2))
except:
raise ValueError('Input map should have I, Q, and U')
have_map2 = False
if isinstance(map2, str):
try:
map2 = H.read_map(map2, field=(0, 1, 2))
except:
raise ValueError('Input map should have I, Q, and U')
have_map2 = True
if isinstance(window, str):
window = H.read_map(window)
elif window is None:
window = np.ones_like(map1[0])
if mask is None:
mask = np.ones_like(map1[0])
#Merge masks/windows
window = window * mask
map1 = (map1[0] * window, map1[1] * window, map1[2] * window)
if have_map2:
if isinstance(window2, str):
window2 = H.read_map(window2)
elif window2 is None:
window2 = window
if isinstance(mask2, str):
mask2 = H.read_map(mask2)
elif mask2 is None:
mask2 = mask
window2 = window2 * mask2
map2 = (map2[0] * window2, map2[1] * window2, map2[2] * window2)
#Remove the monopole and dipole. Points outside the mask/window are set
#to the UNSEEN value so they are ignored when calculating the monopole/
#dipole
if remove_monopole:
idx = window == 0
map1[0][idx] = H.UNSEEN
map1[1][idx] = H.UNSEEN
map1[2][idx] = H.UNSEEN
map1[0][:] = H.remove_monopole(map1[0], verbose=False)
map1[1][:] = H.remove_monopole(map1[1], verbose=False)
map1[2][:] = H.remove_monopole(map1[2], verbose=False)
map1[0][idx] = 0.0
map1[1][idx] = 0.0
map1[2][idx] = 0.0
if have_map2:
idx = window2 == 0
map2[0][idx] = H.UNSEEN
map2[1][idx] = H.UNSEEN
map2[2][idx] = H.UNSEEN
map2[0][:] = H.remove_monopole(map2[0], verbose=False)
map2[1][:] = H.remove_monopole(map2[1], verbose=False)
map2[2][:] = H.remove_monopole(map2[2], verbose=False)
map2[0][idx] = 0.0
map2[1][idx] = 0.0
map2[2][idx] = 0.0
if remove_dipole:
idx = window == 0
map1[0][idx] = H.UNSEEN
map1[1][idx] = H.UNSEEN
map1[2][idx] = H.UNSEEN
map1[0][:] = H.remove_dipole(map1[0], verbose=False)
map1[1][:] = H.remove_dipole(map1[1], verbose=False)
map1[2][:] = H.remove_dipole(map1[2], verbose=False)
map1[0][idx] = 0.0
map1[1][idx] = 0.0
map1[2][idx] = 0.0
if have_map2:
idx = window2 == 0
map2[0][idx] = H.UNSEEN
map2[1][idx] = H.UNSEEN
map2[2][idx] = H.UNSEEN
map2[0][:] = H.remove_dipole(map2[0], verbose=False)
map2[1][:] = H.remove_dipole(map2[1], verbose=False)
map2[2][:] = H.remove_dipole(map2[2], verbose=False)
map2[0][idx] = 0.0
map2[1][idx] = 0.0
map2[2][idx] = 0.0
#Construction of the cls of the maps and masks/weights
cls = H.anafast(map1, map2=map2)
thetas, xi, w, x = get_xi_from_cl(cls,
return_leggauss=True,
thetamax=thetamax)
if window is None:
wls = None
else:
wls = H.anafast(window, map2=window2)
#Compute xi from the cls of the map and masks
thetas, xi_mask = get_xi_from_cl(wls, thetas=thetas)
xi_final = _correct_xi_from_mask(xi, xi_mask)
if decouple:
xi_final = _update_xi(xi_final, x, thetamax, cls, cl_mask=wls)
ncor = len(xi_final)
#apodize the correlation function
if apodizesigma > 0.0:
apfunction = _apodizefunction(x, apodizesigma, thetamax, apodizetype)
for i in range(ncor):
xi_final[i, :] *= apfunction
#compute the cls from xi
cls_out = do_cl_from_xi(xi_final,
w,
x,
decouple=decouple,
apodizesigma=apodizesigma,
apodizetype=apodizetype,
thetamax=thetamax)
#Correct cl for beam, pixel, transfer function???
if returnxi:
return cls_out, xi_final
else:
return cls_out
def solar_dipole_fit(s, gal_cut=30):
import healpy as hp
dipmap = solar_system_dipole_map(nside=hp.npix2nside(len(s)))
return np.sum(hp.remove_monopole(s.filled(), gal_cut=gal_cut) * np.logical_not(s.mask) * dipmap)/np.sum(dipmap ** 2 * np.logical_not(s.mask))
def remove_monopole(data):
"DEPRECATED"
return hp.remove_monopole(data, fitval=False)
def test_anafast_nomask(self):
cl = hp.anafast(hp.remove_monopole(self.map1[0].data), lmax=self.lmax)
self.assertEqual(len(cl), 65)
np.testing.assert_array_almost_equal(cl,
self.cl_fortran_nomask,
decimal=8)
ell = np.arange(len(cl))
plt.plot(ell, ell*(ell+1)*cl)
plt.xlabel('$l$')
plt.ylabel('$l(l+1) C_l$')
plt.show()
clGal = hp.anafast(galMap, lmax=LMAX)
ellGal = np.arange(len(clGal))
plt.plot(ellGal, clGal)
plt.yscale('log')
plt.xscale('log')
plt.xlabel('$l$')
plt.ylabel('$C_l$')
plt.ylim([10**-7, 10**-3])
plt.title('CMASS North dr12 auto-power spectrum')
plt.show()
clCross = hp.anafast(galMap, hp.remove_monopole(planckmapMasked), lmax = LMAX)
ellCross = np.arange(len(clCross))
plt.plot(ellCross, ellCross*(ellCross+1)*clCross)
#plt.xscale('log')
#plt.yscale('log')
plt.xlabel('$l$')
plt.ylabel('$l(l+1)C_l$')
plt.title('CMASS North dr12 and Planck %i GHz cross-power spectrum'%(mapFreq))
plt.show()
import numpy as np
ft = hp.read_map('ftsumner.fits')
al = hp.read_map('alicesprings.fits')
ft[ft<0]=0
al[al<0]=0
NSIDE = 32
hit = hp.ud_grade(ft + al, NSIDE, power=-2)
noise = {8:308, 10:307, 15:163} #microK rt Sec
fsamp = 30. #Hz
#for freq, no in zip([8, 10, 15], noise):
freq = 8
key = 'map'
if freq == 8:
key = 'brian'
signal = gal2eq(hp.remove_monopole(hp.ud_grade(
hp.read_map('/smbmount/data1/COFE/Simulations/COFE_simulationPSMv163/cofe1/frequency_maps/coadded%s_%dGhz.fits' % (key,freq)), NSIDE),gal_cut=50))
if freq == 8:
signal *= 1.e3
noise_map = noise[freq] / np.sqrt(hit * 1/fsamp) / 1e3
signoise = hp.ma(np.absolute(signal)/noise_map)
signoise.mask = hit == 0
hp.mollview(signoise, min=1,max=10.,coord='CG',title='Signal to noise at %d GHz' % freq,xsize=2000, norm='log')
plt.savefig('sigtonoise_%d.png' % freq)
range(3),
verbose=False), nside)
else:
m = hp.ud_grade(
hp.read_map(
'/Users/reijo/data/PR2/frequencymaps/'
'HFI_SkyMap_{:03}_2048_R2.02_full.fits'.format(
freq),
range(3),
verbose=False), nside)
m = hp.smoothing(m,
fwhm=4 * np.pi / 180,
lmax=512,
verbose=False)
m = np.array(m)
m[0] = hp.remove_monopole(m[0], gal_cut=80)
hp.mollview(m[0] * norm,
min=-amp,
max=amp,
sub=[nrow, ncol, ifreq + 1],
title='PR2 {}GHz'.format(freq))
hp.mollview(np.sqrt(m[1]**2 + m[2]**2) * norm,
min=0,
max=pol_amp,
sub=[nrow, ncol, ifreq + ncol + 1],
title='PR2 {}GHz P'.format(freq))
except Exception:
m = None
pass
t1 = MPI.Wtime()
OPTIONS, ARGS = parse_command_line()
validate_args(OPTIONS, ARGS)
Map = create_namedtuple_for_map(OPTIONS)
########################################
# Read the input maps in memory
INPUT_MAPS = []
for cur_title, cur_map_file in zip(*[iter(ARGS)] * 2):
try:
log.info('reading map `%s\'...', cur_map_file)
cur_map = healpy.read_map(cur_map_file, field=OPTIONS.stokes_component)
if OPTIONS.no_monopole:
result = healpy.remove_monopole(cur_map, fitval=True, copy=False)
log.info('monopole has been removed (%s)', str(result))
if OPTIONS.no_dipole:
result = healpy.remove_dipole(cur_map, fitval=True, copy=False)
log.info('dipole has been removed (amplitude: %s)', str(result))
cur_map[cur_map < -1.6e+30] = np.NaN
if type(OPTIONS.mask) is not None:
cur_map[OPTIONS.mask == 0] = np.NaN
cur_entry = dict(title=cur_title,
pixels=cur_map,
input_file=cur_map_file)
if OPTIONS.plot_distributions:
cur_entry['histogram'] = np.histogram(cur_map[~np.isnan(cur_map)],
def test_anafast(self):
cl = hp.anafast(hp.remove_monopole(self.map1[0].filled()), lmax=self.lmax)
self.assertEqual(len(cl), 65)
np.testing.assert_array_almost_equal(cl, self.cla, decimal=8)
def test_anafast_nomask(self):
cl = hp.anafast(hp.remove_monopole(self.map1[0].data), lmax=self.lmax)
self.assertEqual(len(cl), 65)
np.testing.assert_array_almost_equal(cl, self.cl_fortran_nomask, decimal=8)
def powspec(nside,
theta,
phi,
res,
Conf=0.68,
remove_monopole=True,
remove=[],
shift=False):
#Generating a map of the residuals
residuals = pixres(nside, theta, phi, res)
numresiduals = pixarr(nside, theta, phi)
residuals[remove] = hp.UNSEEN
numresiduals[remove] = 0.
for i in range(len(numresiduals)):
if numresiduals[i] == hp.UNSEEN:
numresiduals[i] = 0.
print 'Number of SN Used:', sum(numresiduals)
blockPrint()
if remove_monopole == True:
residuals = hp.remove_monopole(residuals)
enablePrint()
#Finding Norm Factor
dA = hp.nside2pixarea(nside)
omg_sky = 4 * pi - dA * np.count_nonzero(residuals == hp.UNSEEN)
norz = (4 * pi / omg_sky)
#Generating Data Spectrum
cl_dat = hp.anafast(residuals)
ell_dat = np.arange(len(cl_dat))
#Running the Simulations and Finding Normal Spectrum + Error Bars
x = []
y = []
mres = np.copy(res)
for i in range(1001):
np.random.shuffle(mres)
mresiduals = pixres(nside, theta, phi, mres)
blockPrint()
if remove_monopole == True:
mresiduals = hp.remove_monopole(mresiduals)
enablePrint()
cls = hp.anafast(mresiduals)
ell = np.arange(len(cls))
x.extend(ell)
y.extend(cls)
x = np.array(x)
y = np.array(y)
CI = CIL(Conf, x, y)
ell_sim = CI[:, 0]
cl_sim = CI[:, 1]
err_sim = [CI[:, 2], CI[:, 3]]
print "done"
return ell_dat, cl_dat, ell_sim, cl_sim, err_sim, norz
# file names for the input high resolution FITS map and an optional
# downgraded and smoothed version of the same map (when save_lowres is
# enabled)
fn_hires \
= '/project/projectdirs/planck/data/ffp8/mc_noise/{:03}/{:03}_{:02}/ffp8_noise_{:03}_full_map_mc_{:05}.fits'.format( \
freq, freq, real_batch, freq, current_step )
fn_lowres \
= 'maps/mc_noise/{:03}/{:03}_{:02}/ffp8_noise_{:03}_full_map_mc_{:05}.fits'.format( \
freq, freq, real_batch, freq, current_step )
# Read the map from the appropriate Monte Carlo directory.
maps[ifreq] = hp.read_map( fn_hires )
# Remove a global offset from the map (ignores unobserved pixels)
maps[ifreq] = hp.remove_monopole( maps[ifreq] )
# Reduce the resolution first, makes the smoothing faster
maps[ifreq] = hp.ud_grade( maps[ifreq], nside )
# Apply the smoothing kernel
maps[ifreq] = hp.smoothing( maps[ifreq], fwhm=fwhm, lmax=lmax )
if freq < 545:
maps[ifreq][ maps[ifreq] != hp.UNSEEN ] *= 1e6
dpi = 96
layouts = \
{ '1080p' : {'res':[1920, 1080], 'label_font_size':12, 'title_font_size':14, 'cbar_fraction':0.1, 'margins':None},
'720p' : {'res':[1280, 720], 'label_font_size':10, 'title_font_size':12, 'cbar_fraction':0.15, 'margins':None},
'480p' : {'res':[720, 480], 'label_font_size':8, 'title_font_size':10, 'cbar_fraction':0.1, 'margins':None} }
for layout in layouts.itervalues():
m30rh2=hp.ma(hp.read_map(f30rh2,[0,1,2]))
m30ss1=hp.ma(hp.read_map(f30ss1,[0,1,2]))
m30ss2=hp.ma(hp.read_map(f30ss2,[0,1,2]))
m30ss1rh1=hp.ma(hp.read_map(f30ss1rh1,[0,1,2]))
m30ss1rh2=hp.ma(hp.read_map(f30ss1rh2,[0,1,2]))
m30ss2rh1=hp.ma(hp.read_map(f30ss2rh1,[0,1,2]))
m30ss2rh2=hp.ma(hp.read_map(f30ss2rh2,[0,1,2]))
m30rhdiff=[]
m30ssdiff=[]
m30ssrhdiff=[]
for m1,m2 in zip(m30rh1,m30rh2):
m1.mask=tmask30|m1.mask|m2.mask
m2.mask=tmask30|m1.mask|m2.mask
m30rhdiff.append(hp.remove_monopole(m1-m2)/2.)
frac30rh =(1-float(m1.mask.sum())/len(m1.mask))
for m1,m2 in zip (m30ss1,m30ss2):
m1.mask=tmask30|m1.mask|m2.mask
m2.mask=tmask30|m1.mask|m2.mask
m30ssdiff.append(hp.remove_monopole(m1-m2)/2.)
frac30ss=(1-float(m1.mask.sum())/len(m1.mask))
for m1a,m1b,m2a,m2b in zip (m30ss1rh1,m30ss1rh2,m30ss2rh1,m30ss2rh2):
m1a.mask=tmask30|m1a.mask|m2a.mask|m1b.mask|m2b.mask
m1b.mask=m1a.mask
m2a.mask=m1a.mask
m2b.mask=m1a.mask
m30ssrhdiff.append(hp.remove_monopole(m1a+m2a-m1b-m2b)/4.)
frac30ssrh=(1-float(m1a.mask.sum())/len(m1a.mask))
# <codecell>
def test_anafast(self):
cl = hp.anafast(hp.remove_monopole(self.map1[0].filled()),
lmax=self.lmax)
self.assertEqual(len(cl), 65)
np.testing.assert_array_almost_equal(cl, self.cla, decimal=8)
NSIDE = 32
hit = hp.ud_grade(ft + al, NSIDE, power=-2)
noise = {8: 308, 10: 307, 15: 163} #microK rt Sec
fsamp = 30. #Hz
#for freq, no in zip([8, 10, 15], noise):
freq = 8
key = 'map'
if freq == 8:
key = 'brian'
signal = gal2eq(
hp.remove_monopole(hp.ud_grade(
hp.read_map(
'/smbmount/data1/COFE/Simulations/COFE_simulationPSMv163/cofe1/frequency_maps/coadded%s_%dGhz.fits'
% (key, freq)), NSIDE),
gal_cut=50))
if freq == 8:
signal *= 1.e3
noise_map = noise[freq] / np.sqrt(hit * 1 / fsamp) / 1e3
signoise = hp.ma(np.absolute(signal) / noise_map)
signoise.mask = hit == 0
hp.mollview(signoise,
min=1,
max=10.,
coord='CG',
title='Signal to noise at %d GHz' % freq,
xsize=2000,
OPTIONS, ARGS = parse_command_line()
validate_args(OPTIONS, ARGS)
Map = create_namedtuple_for_map(OPTIONS)
########################################
# Read the input maps in memory
INPUT_MAPS = []
for cur_title, cur_map_file in zip(*[iter(ARGS)] * 2):
try:
log.info('reading map `%s\'...', cur_map_file)
cur_map = healpy.read_map(cur_map_file, field=OPTIONS.stokes_component)
if OPTIONS.no_monopole:
result = healpy.remove_monopole(cur_map, fitval=True, copy=False)
log.info('monopole has been removed (%s)', str(result))
if OPTIONS.no_dipole:
result = healpy.remove_dipole(cur_map, fitval=True, copy=False)
log.info('dipole has been removed (amplitude: %s)',
str(result))
cur_map[cur_map < -1.6e+30] = np.NaN
if type(OPTIONS.mask) is not None:
cur_map[OPTIONS.mask == 0] = np.NaN
cur_entry = dict(title=cur_title,
pixels=cur_map,
input_file=cur_map_file)
if OPTIONS.plot_distributions:
"""
STEP 5: Removing monopole and dipole
"""
mapa = hp.read_map('LFI_CompMap_Foregrounds-smica_1024_R2.00.fits')
hp.mollview(mapa, norm='hist', title='all multipoles')
#pyplot.savefig('foreg_all_multipoles.png')
print('<mapa> =', np.mean(mapa))
####################
# Removing DIPOLE:::
mapa2 = hp.remove_monopole(mapa)
print('<mapa2> =', np.mean(mapa2))
hp.mollview(mapa2, norm='hist', title='l >= 1')
#pyplot.savefig('foreg_lge1.png')
mapa_mono = mapa - mapa2
print(mapa_mono)
hp.mollview(mapa_mono, norm='hist', title='l = 0 (monopole)')
pyplot.savefig('foreg_l1.png')
# with and without gal_cut ...
# Compare:::
nside = 1024
else:
nside = 2048
print(freq)
cmb = hp.ud_grade(cmb_hires, nside)
psmask = hp.ud_grade(
hp.read_map(hfi_pipe + 'psmask_{:03}.fits'.format(freq)), nside) < .9
fname = '/global/cscratch1/sd/keskital/npipe_maps/' \
'{}/{}_{:03}_map.fits'.format(ver, ver, freq)
if not os.path.isfile(fname):
fname = '/global/cscratch1/sd/keskital/npipe_maps/' \
'{}/{}_{:03}-1_map.fits'.format(ver, ver, freq)
freqmap = hp.ud_grade(hp.read_map(fname), nside)
freqmap -= cmb
freqmap = hp.remove_monopole(freqmap, gal_cut=70)
low, high = threshhold
mask_low = np.ones(freqmap.size, dtype=np.float32)
mask_high = np.ones(freqmap.size, dtype=np.float32)
weighted_low = freqmap > low
weighted_high = freqmap > high
mask_low[weighted_low] = (low / freqmap[weighted_low])
mask_high[weighted_high] = (high / freqmap[weighted_high])
mask_low[psmask] *= 1e-10
mask_high[psmask] *= 1e-10
mask_madam = mask_high > 0.9
plt.figure(1)
hp.mollview(mask_low,
xsize=1200,
title='{}GHz'.format(freq),
sub=[nrow, ncol, iplot + 1])
l = [70,143,217,353,545,857]
freqs = [100] + l
fs = ["/scratch/r/rbond/msyriac/data/sims/websky/new_cib/cib_ns4096_nu%s.fits" % str(x).zfill(4) for x in freqs]
f0 = 100.
acls = []
anis = []
monos = []
for i,f in enumerate(fs):
freq = freqs[i]
print(freq)
imap = hp.read_map(f)
_,mono = hp.remove_monopole(imap,fitval=True)
ialm = hp.map2alm(imap)
cls = hp.alm2cl(ialm)
ells = np.arange(len(cls))
acls.append(cls)
anis.append(cls[np.logical_and(ells>4000,ells<6000)].mean())
monos.append(mono)
io.save_cols(os.environ['WORK'] + "/new_cib.txt",(freqs,monos,anis))
