def test_load_signal(self):
params = Struct(beam_nside = GSM_NSIDE)
ctx = Struct(params = params)
ctx.frequency = 980.0
astro_signal = gsm.load_signal(ctx)
assert astro_signal is not None
assert hp.get_nside(astro_signal) == ctx.params.beam_nside
root_file_path = resource_filename(hide.__name__, gsm.GSM_FILE_PATH)
file_path = os.path.join(root_file_path, str(params.beam_nside), "gsm_%s.fits"%(ctx.frequency))
gsm_map = hp.read_map(file_path)
assert np.all(gsm_map == astro_signal)
ctx.frequency = 1000.0
astro_signal = gsm.load_signal(ctx)
assert astro_signal is not None
assert hp.get_nside(astro_signal) == ctx.params.beam_nside
file_path = os.path.join(root_file_path, str(params.beam_nside), "gsm_%s.fits"%(ctx.frequency))
gsm_map = hp.read_map(file_path)
assert np.all(gsm_map == astro_signal)
ctx.frequency = 1280.0
astro_signal = gsm.load_signal(ctx)
assert astro_signal is not None
assert hp.get_nside(astro_signal) == ctx.params.beam_nside
file_path = os.path.join(root_file_path, str(params.beam_nside), "gsm_%s.fits"%(ctx.frequency))
gsm_map = hp.read_map(file_path)
assert np.all(gsm_map == astro_signal)
def prepare_map(mapname='HFI_SkyMap_143_2048_R2.02_full.fits',
maskname='HFI_Mask_GalPlane-apo0_2048_R2.00.fits',
field = (0,1,2),
fwhm=0.0,
nside_out=128,
rewrite_map=False,
masktype=None):
newname = mapname[:-5] + '_fwhm_{:.3f}rad_nside_{}_mask_{}.fits'.format(fwhm, nside_out,masktype)
if not os.path.exists(data_path + newname) or rewrite_map:
print 'reading mask...'
mask = hp.read_map(data_path + maskname, field=2)
masknside = hp.get_nside(mask)
if masknside != nside_out:
print 'matching mask to map resolution...'
mask = hp.pixelfunc.ud_grade(mask, nside_out=nside_out)
print 'done'
print 'processing map...'
Imap, Qmap, Umap = hp.read_map( data_path + mapname,
hdu=1, field=(0,1,2) )
mapnside = hp.get_nside(Imap)
if not np.isclose(fwhm, 0.):
Imap = hp.sphtfunc.smoothing( Imap,fwhm=fwhm )
Qmap = hp.sphtfunc.smoothing( Qmap,fwhm=fwhm )
Umap = hp.sphtfunc.smoothing( Umap,fwhm=fwhm )
if mapnside != nside_out:
Imap = hp.pixelfunc.ud_grade( Imap,nside_out=nside_out )
Qmap = hp.pixelfunc.ud_grade( Qmap,nside_out=nside_out )
Umap = hp.pixelfunc.ud_grade( Umap,nside_out=nside_out )
Imap *= mask
Qmap *= mask
Umap *= mask
hp.fitsfunc.write_map( data_path + newname, [Imap, Qmap, Umap])
print 'done'
print 'reading map...'
maps = hp.read_map( data_path + newname,
field=field )
return maps
def map2patch(map,n):
"""
Incomplete
Creates small patches of a larger map
"""
nside = hp.get_nside(map)
pix = np.arange((hp.nside2npix(nside)))
(theta, phi) = hp.pix2ang(nside,pix)
dec = (theta-np.pi/2.0)/np.pi*180.0; ra = phi/2.0/np.pi*360.0
obspix = (map > 0.5)
ri = np.mod(n,5); di = n/5
rap = np.percentile(ra[obspix],[0,20,40,60,80,100])
decp = np.percentile(dec[obspix],50)
ragood = np.logical_and((rap[ri] < ra),(ra < rap[ri+1]))
if di < 1:
decgood = (dec < decp)
else:
decgood = (dec > decp)
gdidx = np.logical_and(np.logical_and(ragood,decgood),obspix)
outmap = np.copy(map)
outmap[gdidx] = 1.0
outmap[np.logical_not(gdidx)] = 0.0
return outmap
def BeamMapComplex( self, RAnow, Bmap, freq ) : ''' return shape = (1, Nv, 12*nside**2) ''' freq = jp.Num(freq, float) RAnow = jp.Num(RAnow, float) Bmap = jp.npfmt(Bmap) coordtrans = jp.CoordTrans() nside = hp.get_nside(Bmap) theta, phi = hp.pix2ang(nside, np.arange(12*nside**2)) #-------------------------------------------------- # For Bmap, rotate points in CeleXYZ from RA=0(+x) to RA=RAnow. Rotate points is negetive angle, so az=-RAnow az = -RAnow if (az != 0) : pixnowB = hp.ang2pix(nside, theta, phi+az*np.pi/180) Bmap = Bmap[pixnowB] pixnowB = 0 #@ # Now Bmapnow is still in CeleXYZ #-------------------------------------------------- # For Tmap, don't need to rotate its points # Then for Tmap and Bmap(now), convert from CeleXYZ to AntXYZ. Note that here rotate XYZ, NOT points, so az=RAnow+90 from lon=0 to +AntX az = 90 + RAnow if (az != 0) : hpixXYZ = coordtrans.xyzRotation(self.hpixCeleXYZ.T, az=az).T else : hpixXYZ = self.hpixCeleXYZ.copy() #-------------------------------------------------- # phase = 2pi/c * \vec(B) * \vec(s) phase = (2*np.pi/300*freq * self.blXYZ[:,None,:] * hpixXYZ[None,:,:]).sum(-1) # (Nv, 12*nside**2) for 1 freq hpixXYZ = 0 #@ #-------------------------------------------------- Bmap = Bmap[None,:] * np.exp(1j*phase) return Bmap[None,:] # None for Nfreq=1
def rotate_tqu(map_in,wl,alpha): #rotates tqu map by phase npix=hp.nside2npix(hp.get_nside(map_in)) tmp_map=np.zeros((3,npix)) tmp_map[0]=map_in[0] tmp_map[1]=map_in[1]*np.cos(2*wl**2*alpha)+map_in[2]*np.sin(2*wl**2*alpha) tmp_map[2]=map_in[2]*np.cos(2*wl**2*alpha)-map_in[1]*np.sin(2*wl**2*alpha) return tmp_map
def test_load_signal_normal(self):
params = Struct(beam_nside=static_gsm.GSM_NSIDE)
ctx = Struct(params = params)
astro_signal = static_gsm.load_signal(ctx)
assert astro_signal is not None
assert hp.get_nside(astro_signal) == ctx.params.beam_nside
def read_healpix_map(self, healpix_map, cmap='viridis'):
# collect the nside of the map
nside = hp.get_nside(healpix_map)
# get the colors of the rays based of their values
_, colors = array_to_cmap(healpix_map, cmap=cmap, use_log=False)
# now go thru all the points on the sphere
for idx, val in enumerate(healpix_map):
if val > 0:
# if the probability is greater than 0
# then we need to get the sky position
ra, dec = Fermi._pix_to_sky(idx, nside)
# mark the color
color = colors[idx]
# now make a point source
ps = SkyCoord(ra, dec, unit='deg', frame='icrs')
# transform into the fermi frame
ps_fermi = ps.transform_to(frame=self._frame)
self.add_ray(ps_fermi, color=color)
def test_map2alm_pol_gal_cut(self):
tmp = [np.empty(o.size * 2) for o in self.mapiqu]
for t, o in zip(tmp, self.mapiqu):
t[::2] = o
maps = [
self.mapiqu,
[o.astype(np.float32) for o in self.mapiqu],
[t[::2] for t in tmp],
]
for use_weights in [False, True]:
for input in maps:
gal_cut = 30
nside = hp.get_nside(input)
npix = hp.nside2npix(nside)
gal_mask = (
np.abs(hp.pix2ang(nside, np.arange(npix), lonlat=True)[1]) < gal_cut
)
alm = hp.map2alm(
input, iter=10, use_weights=use_weights, gal_cut=gal_cut
)
output = hp.alm2map(alm, 32)
for i, o in zip(input, output):
# Testing requires low tolerances because of the
# mask boundary
i[gal_mask] = 0
np.testing.assert_allclose(i, o, atol=1e-2)
def CelestialHealpix( self, healpixmap, ordering, coordin, coordout, epochin='2000', epochout='2000' ) : ''' healpixmap: (1) np.ndarray with shape=(12*nside**2,) (2) int number =nside ordering: 'RINGE' | 'NESTED' return: Case (1) [hpix_in2out, healpixmap_in2out] Case (2) hpix_in2out Usage: healpixmap_in2out = healpixmap[hpix_in2out] ''' try : nside = hp.get_nside(healpixmap) except : nside = self._Nside(healpixmap) ordering, nest = self._Ordering(ordering) hpix_in2out = np.arange(12*nside**2) Decb, RAl = hp.pix2ang(nside, hpix_in2out, nest=nest) Decb = np.pi/2 - Decb RAl, Decb = self.Celestial(RAl, Decb, coordout, coordin, epochout, epochin) hpix_in2out =hp.ang2pix(nside, np.pi/2-Decb,RAl, nest=nest) try : return [hpix_in2out, healpixmap[hpix_in2out]] except : return hpix_in2out
def ApplyPSF(hpix, E_min, E_max, PSFFile='P7Clean_Front+Back.fits', sigma=.1, smoothed=False):
"""
WARNING INCOMPLETE: Normalization off and smoothing below healpix scale explodes.
This method takes a healpix input 'hpix', and a spectrally averaged energy 'E'. It then looks up the corresponding
PSF from tables -> calculates the legendre transform coefficients -> transforms the input pixles into spherical
harmonics -> re-weight the alm coefficients according to the PSF -> returns the inverse transform
**WARNING: DO NOT USE. THIS METHOD IS NOT YET COMPLETED**
"""
# Spherical Harmonic transform
alm = healpy.sphtfunc.map2alm(hpix)
# get maximum value of l
l_max = healpy.sphtfunc.Alm.getlmax(len(alm))
x = np.linspace(-30, 30, 10000) # Cos(0) to Cos(pi)
psf_y = (sigma*np.sqrt(2*np.pi))*np.exp(-x*x/(2*sigma**2))
psf_x = np.cos(np.deg2rad(x))
# Fit the PSF to l_max legendre polynomials
cls = np.sqrt(4*np.pi/(2*np.arange(0, l_max+1)+1))*np.polynomial.legendre.legfit(psf_x, psf_y, l_max)
conv_alm=healpy.sphtfunc.almxfl(alm, cls)
# Find nside and return inverse transformed map.
nside = healpy.get_nside(hpix)
if smoothed is False:
return healpy.sphtfunc.alm2map(conv_alm, nside=nside, verbose=False)
else:
return healpy.sphtfunc.alm2map(alm, nside=nside, sigma=np.deg2rad(sigma), verbose=False)
def hits2mask(mapin):
nside = _hp.get_nside(mapin)
badidx = _np.where(mapin <= 0.0)[0]
mask = np.copy(mapin)
mask[badidx] = 0.0; mask[~badidx] = 1.0
return mask
def deconvolve_map(map_in, fwhm_in=0.0, fwhm_out=0.0, lmax=None, binary_mask=None, pol=False, wiener=True, sky_prior=None):
if fwhm_in == fwhm_out:
return map_in
if lmax is None:
lmax = 3*hp.get_nside(map_in) - 1
if binary_mask is None:
binary_mask = np.logical_not(np.isnan(map_in[0] if pol else map_in))
f_sky = float(np.sum(binary_mask))/binary_mask.size
alm_in = estimate_alm(map_in, lmax, binary_mask, pol)
alm_dec = deconvolve_alm(alm_in, fwhm_in=fwhm_in, fwhm_out=fwhm_out, f_sky=f_sky, pol=pol, wiener=True, sky_prior=sky_prior)
map_dec = hp.alm2map(alm_dec, nside=hp.get_nside(map_in), pol=pol)
return map_dec
def NsideConvert( self, nsideout=None, orderingin=None, inmap=None ) : ''' ''' nsideout = self._NsideCheck(nsideout) orderingin = self._OrderingCheck(orderingin)[0] if (self.verbose and jp.SysFrame(0,2)[-1][-2]=='') : strfont = '' else : strfont = ' ' if (self.verbose) : print strfont+'Tmap2Vis.NsideConvert' nsideinstr = '' if (inmap is None) : print strfont+strfont+"nsidein="+str(hp.get_nside(self.Tmap))+", nsideout="+str(nsideout)+", orderingin='"+orderingin+"'" if(self.verbose and jp.SysFrame(0,2)[-1][-2]==''): print self.Tmap = hp.ud_grade(self.Tmap, nsideout, order_in=orderingin) else : print strfont+strfont+"nsidein="+str(hp.get_nside(inmap))+", nsideout="+str(nsideout)+", orderingin='"+orderingin+"'" if(self.verbose and jp.SysFrame(0,2)[-1][-2]==''): print return hp.ud_grade(inmap, nsideout, order_in=orderingin)
def test_load_signal_rescale(self):
params = Struct(beam_nside = 2**6)
ctx = Struct(params = params)
ctx.frequency = 980
astro_signal = gsm.load_signal(ctx)
assert astro_signal is not None
assert hp.get_nside(astro_signal) == ctx.params.beam_nside
def __init__(self,fname,dir='.',nside=[],cal=1.0):
self.dir=dir
self.fname=fname
self.nside=nside
self.cal=cal
self.map = self._get_a_map_tqu()
if self.nside == []:
self.nside = hp.get_nside(self.map)
return
def get_outline(mapin):
nside = _hp.get_nside(mapin)
outline = _np.array([_hp.UNSEEN]*_hp.nside2npix(nside))
pix = _np.where(mapin>0.0)[0]
for p in pix:
ptmp = _hp.get_all_neighbours(nside,p)
i = _np.where(mapin[ptmp] == 0.0)[0]
outline[ptmp[i]] = 1.0
return outline
def TQU_TO_TEB_maps(sky_TQU, lmax):
nside = hp.get_nside(sky_TQU)
alm_in = hp.map2alm(sky_TQU, lmax, pol=True)
sky_TEB = np.empty((3, 12*nside**2))
for i in range(3):
sky_TEB[i] = hp.alm2map(alm_in[i], nside, pol=False)
return sky_TEB
def get_temp_gradient_map(T_sky, fwhm_in=0.0, fwhm_out=0.0, nside=None, lmax=None):
if nside==None:
nside = hp.get_nside(T_sky)
if lmax==None:
lmax = 3*nside - 1
alm = estimate_alm(T_sky, lmax)
alm_dec = deconvolve_alm(alm, lmax, fwhm_in, fwhm_out)
grad_sky_T = hp.alm2map_der1(alm_dec, nside, lmax)
return grad_sky_T[1:]
def TEB_to_TQU_maps(sky_TEB, lmax):
nside = hp.get_nside(sky_TEB)
alm = np.empty((3, (lmax + 1)**2))
for i in range(3):
alm[i] = hp.map2alm(sky_TEB[i], lmax, pol=False)
sky_TQU = hp.alm2map(alm, nside, lmax, pol=True)
return sky_TQU
def get_dust_opacity(msk,l,b): deg2rad = np.pi/180. nside = hp.get_nside(msk) opac = [8.4e-27, 7.1e-27, 6.8e-27, 6.5e-27 ] err = [3.0e-27, 1.9e-27, 1.8e-27, 1.8e-27 ] theta = (90.0 - b)*deg2rad phi = l*deg2rad pix = hp.ang2pix(nside, theta, phi, nest=False) val = msk[pix] return [ opac[int(val)], err[int(val)] ]
def OrderingConvert( self, orderingin=None, orderingout=None, inmap=None ) : ''' ''' orderingin, nestin, orderingout = self._OrderingCheck(orderingin, orderingout)[:3] if (self.verbose and jp.SysFrame(0,2)[-1][-2]=='') : strfont = '' else : strfont = ' ' if (self.verbose) : print strfont+'Tmap2Vis.OrderingConvert' print strfont+strfont+"orderingin='"+orderingin+"', orderingout='"+orderingout+"'" if (self.verbose and jp.SysFrame(0,2)[-1][-2]=='') : print if (inmap is None) : self.Tmap = hp.ud_grade(self.Tmap, self.nsidein, order_in=orderingin, order_out=orderingout) else : return hp.ud_grade(inmap, hp.get_nside(inmap), order_in=orderingin, order_out=orderingout)
def mask_map_apodised(sky_map, apodised_mask, pol=True):
nside = hp.get_nside(sky_map)
if pol:
masked_map = np.empty((3, 12*nside**2))
for i in range(3):
masked_map[i] = sky_map[i]*apodised_mask
else:
masked_map = sky_map*apodised_mask
f_sky = np.mean(apodised_mask**2)
return masked_map, f_sky
def plug_holes(m, verbose=False, in_place=True, nest=False):
"""
Use simple downgrading to derive estimates of the missing pixel values
"""
autotimer = timing.auto_timer()
nbad_start = np.sum(np.isclose(m, hp.UNSEEN))
if nbad_start == m.size:
if verbose:
print('plug_holes: All map pixels are empty. Cannot plug holes',
flush=True)
return
if nbad_start == 0:
return
nside = hp.get_nside(m)
npix = m.size
if nest:
mnest = m.copy()
else:
mnest = hp.reorder(m, r2n=True)
lowres = mnest
nside_lowres = nside
bad = np.isclose(mnest, hp.UNSEEN)
while np.any(bad) and nside_lowres > 1:
nside_lowres //= 2
lowres = hp.ud_grade(lowres, nside_lowres, order_in='NESTED')
hires = hp.ud_grade(lowres, nside, order_in='NESTED')
bad = np.isclose(mnest, hp.UNSEEN)
mnest[bad] = hires[bad]
nbad_end = np.sum(bad)
if nbad_end != 0:
mn = np.mean(mnest[np.logical_not(bad)])
mnest[bad] = mn
if not in_place:
m = m.copy()
if nest:
m[:] = mnest
else:
m[:] = hp.reorder(mnest, n2r=True)
if verbose and nbad_start != 0:
print('plug_holes: Filled {} missing pixels ({:.2f}%), lowest '
'resolution was Nside={}.'.format(
nbad_start, (100.*nbad_start) // npix, nside_lowres))
del autotimer
return m
def Equa2GalaHeal( self, healpixmap, ordering='RING', epoch='2000' ): ''' healpixmap: Healpix map with nside=2**n, total pixels=12*nside**2 ordering: 'RING' or 'NESTED' ''' nside = hp.get_nside(healpixmap) l, b, nest = self._Nside2LonLat(nside, ordering) RA, Dec = self.Gala2Equa(l, b, epoch) n =hp.ang2pix(nside, (90-Dec)*np.pi/180, RA*np.pi/180, nest=nest) return healpixmap[n]
def map_variance(input_map, nside):
inp_nside = healpy.get_nside(input_map)
# Convert to NESTED and then take advantage of this to group into lower
# resolution pixels
map_nest = healpy.reorder(input_map, r2n=True)
map_nest = map_nest.reshape(-1, (inp_nside / nside) ** 2)
# Calculate the variance in each low resolution pixel
var_map = map_nest.var(axis=1)
# Convert back to RING and return
return healpy.reorder(var_map, n2r=True)
def sph_ps(map1, map2=None, lmax=None):
lmax = lmax if lmax is not None else (3*healpy.get_nside(map1) - 1)
alm1 = sphtrans_real(map1, lmax)
alm2 = sphtrans_real(map2, lmax) if map is not None else alm1
prod = alm1 * alm2.conj()
s = prod[:, 0] + 2 * prod[:, 1:].sum(axis=1).real
cl = s / (2.0*np.arange(lmax+1)+1.0)
return cl
def rotate_map(hpmap,coord=['C','G'],cov=True):
'''
Rotates the coordinates of a map
By default, rotates from C to G
'''
(theta,phi) = _hp.pix2ang(_hp.get_nside(hpmap),
_np.arange(0, len(hpmap)))
r = _hp.Rotator(coord=coord, inv = True)
#rotate new coordinate system to original coordinates
theta_map, phi_map = r(theta, phi)
rotated = _hp.get_interp_val(hpmap, theta_map, phi_map)
if cov:
ind1 = (rotated > 0.5); rotated[ind1] = 1.0; rotated[~ind1] = 0.0
return rotated
def local_prob (vgal_ra, vgal_dec, map_ra, map_dec, map_val, target_ra, target_dec, inj_ra, inj_dec) :
import healpy as hp
import rotate
# rotate the galaxy coordinates to that place on the map
# the way this works is that first the target galaxy is rotated onto the origin, bringing
# its friends with it, then the origin is shifted onto the sim map position.
ra, dec = rotate.rotateSkyToOrigin(vgal_ra, vgal_dec, target_ra, target_dec)
ra, dec = rotate.rotateSkyAwayFromOrigin(ra, dec, inj_ra, inj_dec)
# get the weights for that map. this works because the galaxy vector remains ordered.
nsides = hp.get_nside(map_val)
phi = ra*2*np.pi/360.;
theta = (90-dec)*2*np.pi/360.
pix = hp.ang2pix(nsides,theta,phi)
local = map_val[pix]
ix = np.invert(np.isnan(local)) & ( local > 3e-7) # 99% inside GW map
return local, ix
def map2patch_100(map,n):
nside = hp.get_nside(map)
pix = np.arange((hp.nside2npix(nside)))
(theta, phi) = hp.pix2ang(nside,pix)
dec = (theta-np.pi/2.0)/np.pi*180.0; ra = phi/2.0/np.pi*360.0
obspix = (map > 0.5)
ri = np.mod(n,10); di = n/10
bins = range(0,110,10)
rap = np.percentile(ra[obspix],bins)
decp = np.percentile(dec[obspix],bins)
ragood = np.logical_and((rap[ri] < ra),(ra < rap[ri+1]))
decgood = np.logical_and((decp[di] < dec),(dec < decp[di+1]))
gdidx = np.logical_and(np.logical_and(ragood,decgood),obspix)
outmap = np.copy(map)
outmap[gdidx] = 1.0
outmap[np.logical_not(gdidx)] = 0.0
return outmap
def get_sky_map(self):
if self.config.sim_pol_type == "noise_only":
self.sky_map = None
elif self.config.sim_pol_type == "T":
self.sky_map = hp.read_map(self.config.input_map, verbose=False)
elif self.config.sim_pol_type == "QU":
self.sky_map = hp.read_map(self.config.input_map, field=(0,1), verbose=False)
elif self.config.sim_pol_type == "_QU":
self.sky_map = hp.read_map(self.config.input_map, field=(1,2), verbose=False)
else:
self.sky_map = hp.read_map(self.config.input_map, field=(0,1,2), verbose=False)
if not self.config.sim_pol_type == "noise_only":
map_nside = hp.get_nside(self.sky_map)
if map_nside != self.config.nside_in:
prompter.prompt_warning("NSIDE of config does not match NSIDE of map")
sys.exit()
self.npix = hp.nside2npix(self.config.nside_in)
def generate_from_fitsfile(filename, language):
healpix_data, header = healpy.read_map(filename, h=True)
try:
healpix_data, distmu, distsigma, distnorm = healpy.read_map(
filename, field=[0, 1, 2, 3])
dim = 3
except:
dim = 2
print("dimension = %d" % dim)
if dim == 3:
ii = (~numpy.isinf(distmu)) & (distmu > 0.0)
print("good percent %.2f" % (numpy.sum(ii) * 100.0 / len(distmu)))
dm = distmu[ii]
prob = healpix_data[ii]
x = numpy.multiply(prob, dm)
print("Average distance %.2f " % (numpy.sum(x) / numpy.sum(prob)))
wanted = [
'DATE', 'DATE-OBS', 'INSTRUME', 'MJD-OBS', 'DISTMEAN', 'DISTSTD',
'REFERENC'
]
meta = {}
for (k, v) in header:
if k in wanted:
meta[k] = v
print("Generating contours...")
skymapID = get_md(filename)
contours = []
levels = []
deciles = []
percentile = numpy.linspace(0.9, 0.1, 9)
for p in percentile:
(level, area) = get_level(healpix_data, p)
levels.append(level)
deciles.append([p * 100, area])
meta['deciles'] = deciles
for l in levels:
print(l)
# make latitude histogram
nside = healpy.get_nside(healpix_data)
allipix = numpy.arange(0, len(healpix_data))
(th, ph) = healpy.pix2ang(nside, allipix)
h = []
max = 0
for i in range(len(healpix_data)):
if healpix_data[i] > max:
max = healpix_data[i]
imax = i
if healpix_data[i] > levels[2]:
ira = int(ph[i] * radian / 5.0)
idec = int(th[i] * radian / 5.0)
pair = [ira, idec]
if pair not in h:
h.append(pair)
print(h)
meta['histogram'] = h
# make countours
ngrid = 800
apointRA = ph[imax] * radian
apointDec = 90 - th[imax] * radian
meta['apointRA'] = apointRA
meta['apointDec'] = apointDec
print('max prob %f %f' % (apointRA, apointDec))
theta = numpy.linspace(0, numpy.pi, ngrid)
phi = numpy.linspace(0, 2 * numpy.pi, 2 * ngrid)
p, t = numpy.meshgrid(phi, theta)
data_interpolated_to_grid = healpy.pixelfunc.get_interp_val(
healpix_data, t, p)
contourplot = plt.contour(p, t, data_interpolated_to_grid, levels=levels)
numcontours = 0
contours = []
for n, c in enumerate(contourplot.collections):
color = hsv2rgb(n * 1.0 / len(levels), 1.0, 1.0)
for contourPath, path in enumerate(c.get_paths()):
plist = []
for v in path.vertices:
plist.append([v[0] * radian, 90 - v[1] * radian])
spaths = splitPaths(plist)
for sp in spaths:
contours.append({
"name": "%d-percentile" % ((n + 1) * 10),
"color": color,
"coords": sp
})
# contours.append({"name":"%d-percentile"%((n+1)*10), "color":color, "coords":plist})
numcontours += 1
print("made %d polylines" % numcontours)
# galaxies from Glade
gc = galaxyCatalog.gc(glade_filename)
gc.info()
de = gc.declination
ra = gc.right_ascension
name = numpy.array(gc.name)
print("has %d sources" % len(ra))
ph_at_sources = ra / radian
th_at_sources = (90 - de) / radian
skymap_at_sources = numpy.zeros(len(ra))
weighted_sources = numpy.zeros(len(ra))
# distribution of log distance
ldc = gc.log_distance_centres
dh = gc.distance_hist
if dim == 2:
distance = gc.distance
for i in range(len(ra)):
ipix = healpy.ang2pix(nside, th_at_sources[i], ph_at_sources[i])
skymap_at_sources[i] = healpix_data[ipix]
weighted_sources[i] = skymap_at_sources[i]
if dim == 3:
distance = gc.distance
distance_pdf = numpy.zeros(len(ra))
for i in range(len(ra)):
ipix = healpy.ang2pix(nside, th_at_sources[i], ph_at_sources[i])
skymap_at_sources[i] = healpix_data[ipix]
norm = distnorm[ipix]
sigma = distsigma[ipix]
mu = distmu[ipix]
if math.isnan(distance[i]):
distance_pdf[i] = 0.0
for k in range(len(ldc)):
d = math.pow(10.0, ldc[k])
r = math.exp(-(d - mu)**2 / (2 * sigma**2)) * norm * (d**2)
distance_pdf[i] += r * dh[k]
else:
d = distance[i]
distance_pdf[i] = math.exp(-(d - mu)**2 /
(2 * sigma**2)) * norm * (d**2)
weighted_sources[i] = skymap_at_sources[i] * distance_pdf[i]
weighted_sources = numpy.array(weighted_sources)
maxw = numpy.max(weighted_sources)
sumw = numpy.sum(weighted_sources)
print('max weight = ', maxw)
index = numpy.argsort(-weighted_sources)
num = len(index)
if num > 200: num = 200
selected_sources = (index[:num])
print("Selected %d galaxies" % len(selected_sources))
sources = []
for de, ra, nm, w, distance in zip(de[selected_sources],
ra[selected_sources],
name[selected_sources],
weighted_sources[selected_sources],
distance[selected_sources]):
absw = w / sumw # weight compared to total weight
sw = math.sqrt(w / maxw) # normalized sqrt of weight
if sw < 1.e-3: continue
if math.isnan(distance): distance = 0.0
sources.append({
"coords": [ra, de],
"name": nm,
"sw": sw,
"absw": absw,
"distance": distance
})
n += 1
print("Sources complete with %d" % n)
print("Language = ", language)
return make_json(meta, contours, sources)
if mpiutil.rank0:
## Useful output
print("==================================")
print("Projecting file:\n %s\ninto:\n %s" %
(args.mapfile, args.outfile))
print("Using beamtransfer: %s" % args.teldir)
print("Truncating to modes with S/N > %f" % cut)
print("==================================")
# Calculate alm's and broadcast
print("Read in skymap.")
f = h5py.File(args.mapfile)
skymap = f["map"][:]
f.close()
nside = healpy.get_nside(skymap[0])
alm = hputil.sphtrans_sky(skymap, lmax=cyl.lmax)
# else:
# almr = None
mpiutil.world.Bcast([alm, MPI.COMPLEX16], root=0)
cb = cyl.baselines + np.array([[cyl.u_width, 0.0]])
if cyl.positive_m_only:
taumax = (cb**2).sum(axis=-1)**0.5 / 3e8
else:
taumax = (np.concatenate((cb, cb))**2).sum(axis=-1)**0.5 / 3e8
tau = np.fft.fftfreq(cyl.nfreq,
(cyl.frequencies[1] - cyl.frequencies[0]) * 1e6)
# coding: utf-8
import numpy as np, curvedsky as cs, healpy as hp, local, warnings, misctools, tools_cib
warnings.filterwarnings("ignore")
ascale = 1.0
for freq in ['545', '857']:
for field, wind in zip([0, 1, 2, 3], ['G20', 'G40', 'G60', 'G70']):
iobj = tools_cib.init_cib(wind=wind, ascale=ascale)
if misctools.check_path([iobj.fmask, iobj.famask],
overwrite=False,
verbose=False):
continue
# bad pixel
Imask = hp.fitsfunc.read_map(
'/global/homes/t/toshiyan/scratch/PR2/mask/HFI_Mask_GalPlane-apo0_2048_R2.00.fits',
field=field)
nside = hp.get_nside(Imask)
# apodized
amask = cs.utils.apodize(nside, Imask, ascale)
# save
hp.fitsfunc.write_map(iobj.fmask, Imask, overwrite=True)
hp.fitsfunc.write_map(iobj.famask, amask, overwrite=True)
def fe_jump(self, x, iter, beta):
q = x.copy()
lqxy = 0
fe_limit = np.max(self.fe)
#draw skylocation and frequency from f-stat map
accepted = False
while accepted==False:
log_f_new = self.params[self.pimap['log10_fgw']].sample()
f_idx = (np.abs(np.log10(self.fe_freqs) - log_f_new)).argmin()
gw_theta = np.arccos(self.params[self.pimap['cos_gwtheta']].sample())
gw_phi = self.params[self.pimap['gwphi']].sample()
hp_idx = hp.ang2pix(hp.get_nside(self.fe), gw_theta, gw_phi)
fe_new_point = self.fe[f_idx, hp_idx]
if np.random.uniform()<(fe_new_point/fe_limit):
accepted = True
#draw other parameters from prior
cos_inc = self.params[self.pimap['cos_inc']].sample()
psi = self.params[self.pimap['psi']].sample()
phase0 = self.params[self.pimap['phase0']].sample()
log10_h = self.params[self.pimap['log10_h']].sample()
#put new parameters into q
signal_name = 'cw'
for param_name, new_param in zip(['log10_fgw','gwphi','cos_gwtheta','cos_inc','psi','phase0','log10_h'],
[log_f_new, gw_phi, np.cos(gw_theta), cos_inc, psi, phase0, log10_h]):
q[self.pimap[param_name]] = new_param
#calculate Hastings ratio
log_f_old = x[self.pimap['log10_fgw']]
f_idx_old = (np.abs(np.log10(self.fe_freqs) - log_f_old)).argmin()
gw_theta_old = np.arccos(x[self.pimap['cos_gwtheta']])
gw_phi_old = x[self.pimap['gwphi']]
hp_idx_old = hp.ang2pix(hp.get_nside(self.fe), gw_theta_old, gw_phi_old)
fe_old_point = self.fe[f_idx_old, hp_idx_old]
if fe_old_point>fe_limit:
fe_old_point = fe_limit
log10_h_old = x[self.pimap['log10_h']]
phase0_old = x[self.pimap['phase0']]
psi_old = x[self.pimap['psi']]
cos_inc_old = x[self.pimap['cos_inc']]
hastings_extra_factor = self.params[self.pimap['log10_h']].get_pdf(log10_h_old)
hastings_extra_factor *= 1/self.params[self.pimap['log10_h']].get_pdf(log10_h)
hastings_extra_factor = self.params[self.pimap['phase0']].get_pdf(phase0_old)
hastings_extra_factor *= 1/self.params[self.pimap['phase0']].get_pdf(phase0)
hastings_extra_factor = self.params[self.pimap['psi']].get_pdf(psi_old)
hastings_extra_factor *= 1/self.params[self.pimap['psi']].get_pdf(psi)
hastings_extra_factor = self.params[self.pimap['cos_inc']].get_pdf(cos_inc_old)
hastings_extra_factor *= 1/self.params[self.pimap['cos_inc']].get_pdf(cos_inc)
lqxy = np.log(fe_old_point/fe_new_point * hastings_extra_factor)
return q, float(lqxy)
def maps2cld(maps):
r"""Calculate the angular power spectrum of a given map or maps.
Parameters
----------
maps : array_like
A single map or array/list of maps. It must be a HEALPix map, i.e.,
the number of indices must correspond to a nside value.
Returns
-------
cld : dict
A dictionary whose keys correspond to the 'full' power spectrum
and the same without the :math:`a_{\ell 0}` modes, denoted 'mdz'. The
values of `cld` are ndarrays with dimensions dependent on the number
of entry maps and their resolution.
averd : dict
If more than one map is given, the averaged power spectrum is calculated.
Its keys are also 'full' and 'mdz'. Its values are lists of arrays: index
0 corresponds to the mean `cld` value, while index 1 is the error on the
mean.
Notes
-----
A 'full' angular power spectrum has the following expression:
.. math:: C_{\ell} = \frac{1}{2\ell + 1}\sum_{m = -\ell}^{m = \ell} |a_{\ell m}|^2,
while 'mdz', which stands for :math:`m\neq0` has the form
.. math:: C^{m\neq0}_{\ell} = C_{\ell} - \frac{1}{2\ell + 1} |a_{\ell 0}|^2,
:math:`a_{\ell m}` are the coefficients associated with the spherical harmonics :math:`Y_{\ell m}`.
"""
if maps[0].ndim == 0:
nevts, nside = 1, hp.get_nside(maps)
maps = [maps]
else:
nevts, nside = len(maps), hp.get_nside(maps[0])
js = np.arange(3 * nside)
cld = {
'full': np.zeros((nevts, 3 * nside)),
'mdz': np.zeros((nevts, 3 * nside - 1))
}
ii = 0
for emap in maps:
cld['full'][ii, :], alms = hp.anafast(emap, alm=True)
c0s = 1. / (2. * js + 1.) * np.abs(alms[js])**2
cld['mdz'][ii, :] = cld['full'][ii, 1:] - c0s[1:]
ii += 1
if nevts != 1:
averd = {}
for key in cld.keys():
averd[key] = [
np.mean(cld[key], axis=0),
np.std(cld[key], axis=0, ddof=1) / np.sqrt(nevts)
]
return cld, averd
else:
for key in cld.keys():
cld[key] = cld[key][0]
return cld
def multi_res_comp_sep(components, instrument, data, nsides,
**minimize_kwargs):
""" Basic component separation
Parameters
----------
components: list
List storing the :class:`Component` s of the mixing matrix
instrument:
Object that provides the following as a key or an attribute.
- **frequency**
- **depth_i** or **depth_p** (optional, frequencies are inverse-noise
weighted according to these noise levels)
They can be anything that is convertible to a float numpy array.
data: ndarray or MaskedArray
Data vector to be separated. Shape *(n_freq, ..., n_pix).*
*...* can be
- absent or 1: temperature maps
- 2: polarization maps
- 3: temperature and polarization maps (see note)
Values equal to `hp.UNSEEN` or, if `MaskedArray`, masked values are
neglected during the component separation process.
nsides: seq
Specify the ``nside`` for each free parameter of the components
Returns
-------
result: dict
It includes
- **param**: *(list)* - Names of the parameters fitted
- **x**: *(seq)* - ``x[i]`` is the best-fit (map of) the *i*-th
parameter. The map has ``nside = nsides[i]``
- **Sigma**: *(ndarray)* - ``Sigma[i, j]`` is the (map of) the
semi-analytic covariance between the *i*-th and the *j*-th parameter.
It is meaningful only in the high signal-to-noise regime and when the
*cov* is the true covariance of the data
- **s**: *(ndarray)* - Component amplitude maps
- **mask_good**: *(ndarray)* - mask of the entries actually used in the
component separation
Note
----
* During the component separation, a pixel is masked if at least one of
its frequencies is masked.
* If you provide temperature and polarization maps, they will constrain the
**same** set of parameters. In particular, separation is **not** done
independently for temperature and polarization. If you want an
independent fitting for temperature and polarization, please launch
>>> res_T = basic_comp_sep(component_T, instrument, data[:, 0], **kwargs)
>>> res_P = basic_comp_sep(component_P, instrument, data[:, 1:], **kwargs)
"""
instrument = standardize_instrument(instrument)
max_nside = max(nsides)
if max_nside == 0:
return basic_comp_sep(components, instrument, data, **minimize_kwargs)
# Prepare mask and set to zero all the frequencies in the masked pixels:
# NOTE: mask are bad pixels
mask = _intersect_mask(data)
data = hp.pixelfunc.ma_to_array(data).copy()
data[..., mask] = 0 # Thus no contribution to the spectral likelihood
try:
data_nside = hp.get_nside(data[0])
except TypeError:
raise ValueError("data has to be a stack of healpix maps")
invN = _get_prewhiten_factors(instrument, data.shape, data_nside)
invN = np.diag(invN**2)
def array2maps(x):
i = 0
maps = []
for nside in nsides:
npix = _my_nside2npix(nside)
maps.append(x[i:i + npix])
i += npix
return maps
extra_dim = [1] * (data.ndim - 1)
unpack = lambda x: [
_my_ud_grade(m, max_nside).reshape(-1, *extra_dim)
for m in array2maps(x)
]
# Traspose the the data and put the pixels that share the same spectral
# indices next to each other
n_pix_max_nside = hp.nside2npix(max_nside)
pix_ids = np.argsort(hp.ud_grade(np.arange(n_pix_max_nside), data_nside))
data = data.T[pix_ids].reshape(n_pix_max_nside,
(data_nside // max_nside)**2,
*data.T.shape[1:])
back_pix_ids = np.argsort(pix_ids)
A = MixingMatrix(*components)
assert A.n_param == len(nsides), ("%i free parameters but %i nsides" %
(len(A.defaults), len(nsides)))
A_ev = A.evaluator(instrument.frequency, unpack)
A_dB_ev = A.diff_evaluator(instrument.frequency, unpack)
x0 = [x for c in components for x in c.defaults]
x0 = [
np.full(_my_nside2npix(nside), px0) for nside, px0 in zip(nsides, x0)
]
x0 = np.concatenate(x0)
if len(x0) == 0:
A_ev = A_ev()
comp_of_dB = [(c_db,
_my_ud_grade(np.arange(_my_nside2npix(p_nside)), max_nside))
for p_nside, c_db in zip(nsides, A.comp_of_dB)]
# Component separation
res = alg.comp_sep(A_ev, data, invN, A_dB_ev, comp_of_dB, x0,
**minimize_kwargs)
# Craft output
# 1) Apply the mask, if any
# 2) Restore the ordering of the input data (pixel dimension last)
def restore_index_mask_transpose(x):
x = x.reshape(-1, *x.shape[2:])[back_pix_ids]
x[mask] = hp.UNSEEN
return x.T
res.params = A.params
res.s = restore_index_mask_transpose(res.s)
res.chi = restore_index_mask_transpose(res.chi)
if 'chi_dB' in res:
for i in range(len(res.chi_dB)):
res.chi_dB[i] = restore_index_mask_transpose(res.chi_dB[i])
if len(x0) > 0:
x_masks = [
_my_ud_grade(mask.astype(float), nside) == 1. for nside in nsides
]
res.x = array2maps(res.x)
for x, x_mask in zip(res.x, x_masks):
x[x_mask] = hp.UNSEEN
res.mask_good = ~mask
return res
def test_ghosts(lmax=700,
mmax=5,
fwhm=43,
ra0=-10,
dec0=-57.5,
az_throw=50,
scan_speed=2.8,
rot_period=4.5 * 60 * 60,
hwp_mode=None):
'''
Similar test to `scan_bicep`, but includes reflected ghosts
Simulates a 24h BICEP2-like scan strategy
using a random LCDM realisation and a 3 x 3 grid
of Gaussian beams pairs. Bins tods into maps and
compares to smoothed input maps (no pair-
differencing). MPI-enabled.
Keyword arguments
---------
lmax : int,
bandlimit (default : 700)
mmax : int,
assumed azimuthal bandlimit beams (symmetric in this example
so 2 would suffice) (default : 5)
fwhm : float,
The beam FWHM in arcmin (default : 40)
ra0 : float,
Ra coord of centre region (default : -10)
dec0 : float, (default : -57.5)
Ra coord of centre region
az_throw : float,
Scan width in azimuth (in degrees) (default : 50)
scan_speed : float,
Scan speed in deg/s (default : 1)
rot_period : float,
The instrument rotation period in sec
(default : 600)
hwp_mode : str, None
HWP modulation mode, either "continuous",
"stepped" or None. Use freq of 1 or 1/10800 Hz
respectively (default : None)
'''
mlen = 24 * 60 * 60 # hardcoded mission length
# Create LCDM realization
ell, cls = get_cls()
np.random.seed(25) # make sure all MPI ranks use the same seed
alm = hp.synalm(cls, lmax=lmax, new=True, verbose=True) # uK
b2 = ScanStrategy(
mlen, # mission duration in sec.
sample_rate=12.01, # sample rate in Hz
location='spole') # Instrument at south pole
# Create a 3 x 3 square grid of Gaussian beams
b2.create_focal_plane(nrow=3, ncol=3, fov=5, lmax=lmax, fwhm=fwhm)
# Create reflected ghosts for every detector
# We create two ghosts per detector. They overlap
# but have different fwhm. First ghost is just a
# scaled down version of the main beam, the second
# has a much wider Gaussian shape.
# After this initialization, the code takes
# the ghosts into account without modifications
b2.create_reflected_ghosts(b2.beams,
amplitude=0.01,
ghost_tag='ghost_1',
dead=False)
b2.create_reflected_ghosts(b2.beams,
amplitude=0.01,
fwhm=100,
ghost_tag='ghost_2',
dead=False)
# calculate tods in two chunks
b2.partition_mission(0.5 * b2.nsamp)
# Allocate and assign parameters for mapmaking
b2.allocate_maps(nside=256)
# set instrument rotation
b2.set_instr_rot(period=rot_period, angles=[68, 113, 248, 293])
# Set HWP rotation
if hwp_mode == 'continuous':
b2.set_hwp_mod(mode='continuous', freq=1.)
elif hwp_mode == 'stepped':
b2.set_hwp_mod(mode='stepped', freq=1 / (3 * 60 * 60.))
# Generate timestreams, bin them and store as attributes
b2.scan_instrument_mpi(alm,
verbose=1,
ra0=ra0,
dec0=dec0,
az_throw=az_throw,
nside_spin=256,
max_spin=mmax)
# Solve for the maps
maps, cond = b2.solve_for_map(fill=np.nan)
# Plotting
if b2.mpi_rank == 0:
print('plotting results')
cart_opts = dict(
rot=[ra0, dec0, 0],
lonra=[-min(0.5 * az_throw, 90),
min(0.5 * az_throw, 90)],
latra=[-min(0.375 * az_throw, 45),
min(0.375 * az_throw, 45)],
unit=r'[$\mu K_{\mathrm{CMB}}$]')
# plot rescanned maps
plot_iqu(maps,
'../scratch/img/',
'rescan_ghost',
sym_limits=[250, 5, 5],
plot_func=hp.cartview,
**cart_opts)
# plot smoothed input maps
nside = hp.get_nside(maps[0])
hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
maps_raw = hp.alm2map(alm, nside, verbose=False)
plot_iqu(maps_raw,
'../scratch/img/',
'raw_ghost',
sym_limits=[250, 5, 5],
plot_func=hp.cartview,
**cart_opts)
# plot difference maps
for arr in maps_raw:
# replace stupid UNSEEN crap
arr[arr == hp.UNSEEN] = np.nan
diff = maps_raw - maps
plot_iqu(diff,
'../scratch/img/',
'diff_ghost',
sym_limits=[1e+1, 1e-1, 1e-1],
plot_func=hp.cartview,
**cart_opts)
# plot condition number map
cart_opts.pop('unit', None)
plot_map(cond,
'../scratch/img/',
'cond_ghost',
min=2,
max=5,
unit='condition number',
plot_func=hp.cartview,
**cart_opts)
# plot input spectrum
cls[3][cls[3] <= 0.] *= -1.
dell = ell * (ell + 1) / 2. / np.pi
plt.figure()
for i, label in enumerate(['TT', 'EE', 'BB', 'TE']):
plt.semilogy(ell, dell * cls[i], label=label)
plt.legend()
plt.ylabel(r'$D_{\ell}$ [$\mu K^2_{\mathrm{CMB}}$]')
plt.xlabel(r'Multipole [$\ell$]')
plt.savefig('../scratch/img/cls_ghost.png')
plt.close()
def Plotter(
input,
dataset,
nside,
auto,
min,
max,
mid,
rng,
colorbar,
lmax,
fwhm,
mask,
mfill,
sig,
remove_dipole,
logscale,
size,
white_background,
darkmode,
png,
cmap,
title,
ltitle,
unit,
scale,
outdir,
verbose,
data,
):
rcParams["backend"] = "agg" if png else "pdf"
rcParams["legend.fancybox"] = True
rcParams["lines.linewidth"] = 2
rcParams["savefig.dpi"] = 300
rcParams["axes.linewidth"] = 1
masked = False
if darkmode:
rcParams["text.color"] = "white" # axes background color
rcParams["axes.facecolor"] = "white" # axes background color
rcParams["axes.edgecolor"] = "white" # axes edge color
rcParams["axes.labelcolor"] = "white"
rcParams["xtick.color"] = "white" # color of the tick labels
rcParams["ytick.color"] = "white" # color of the tick labels
rcParams["grid.color"] = "white" # grid color
rcParams[
"legend.facecolor"] = "inherit" # legend background color (when 'inherit' uses axes.facecolor)
rcParams[
"legend.edgecolor"] = "white" # legend edge color (when 'inherit' uses axes.edgecolor)
rc(
"text.latex",
preamble=r"\usepackage{sfmath}",
)
# Which signal to plot
print("")
print("")
print("{:#^48}".format(""))
#if len(input)==1: input = input[0]
print("Plotting", input)
#######################
#### READ MAP #####
#######################
# Get maps array if .h5 file
if input.endswith(".h5"):
from src.commands import h5map2fits
from src.tools import alm2fits_tool
# Get maps from alm data in .h5
if dataset.endswith("alm"):
print("Converting alms to map")
(
maps,
nsid,
lmax,
fwhm,
outfile,
) = alm2fits_tool(
input,
dataset,
nside,
lmax,
fwhm,
save=False,
)
# Get maps from map data in .h5
elif dataset.endswith("map"):
print("Reading map from h5")
(
maps,
nsid,
lmax,
outfile,
) = h5map2fits(input, dataset, save=False)
# Found no data specified kind in .h5
else:
print("Dataset not found. Breaking.")
print(f"Does {input}/{dataset} exist?")
sys.exit()
# Plot all signals specified
print(f"Plotting the following signals: {sig}")
print("{:#^48}".format(""))
for polt in sig:
signal_label = get_signallabel(polt)
if data is not None:
m = data.copy()
m = hp.ma(m)
nsid = hp.get_nside(m)
outfile = input.replace(".fits", "")
else:
try:
if input.endswith(".fits"):
map, header = hp.read_map(
input,
field=polt,
verbose=False,
h=True,
dtype=None,
)
header = dict(header)
try:
signal_label = header[f"TTYPE{polt+1}"]
if signal_label in ["TEMPERATURE", "TEMP"]:
signal_label = "T"
if signal_label in [
"Q-POLARISATION", "Q_POLARISATION"
]:
signal_label = "Q"
if signal_label in [
"U-POLARISATION", "U_POLARISATION"
]:
signal_label = "U"
except:
pass
m = hp.ma(map) # Dont use header for this
nsid = hp.get_nside(m)
outfile = input.replace(".fits", "")
elif input.endswith(".h5"):
m = maps[polt]
except:
print(f"{polt} not found")
sys.exit()
############
# SMOOTH #
############
if fwhm > 0 and input.endswith(".fits"):
print("")
print(f"Smoothing fits map to {fwhm} arcmin fwhm")
print("")
m = hp.smoothing(
m,
fwhm=arcmin2rad(fwhm),
lmax=lmax,
)
############
# UD_GRADE #
############
if nside is not None and input.endswith(".fits"):
if nsid != nside:
print(f"UDgrading map from {nsid} to {nside}")
m = hp.ud_grade(
m,
nside,
)
else:
nside = nsid
########################
#### remove dipole #####
########################
if remove_dipole:
starttime = time.time()
print("Removing dipole:")
dip_mask_name = remove_dipole
# Mask map for dipole estimation
m_masked = hp.ma(m)
m_masked.mask = np.logical_not(
hp.read_map(
dip_mask_name,
verbose=False,
dtype=None,
))
# Fit dipole to masked map
mono, dip = hp.fit_dipole(m_masked)
print(f"Dipole vector: {dip}")
print(f"Dipole amplitude: {np.sqrt(np.sum(dip ** 2))}")
# Create dipole template
nside = int(nside)
ray = range(hp.nside2npix(nside))
vecs = hp.pix2vec(nside, ray)
dipole = np.dot(dip, vecs)
# Subtract dipole map from data
m = m - dipole
print(f"Dipole removal : {(time.time() - starttime)}"
) if verbose else None
#######################
#### Auto-param #####
#######################
# Reset these every signal
tempmin = min
tempmax = max
temptitle = title
templtitle = ltitle
tempunit = unit
templogscale = logscale
tempcmap = cmap
# ttl, unt and cmb are temporary variables for title, unit and colormap
if auto:
(
_title,
ticks,
cmp,
lgscale,
scale,
) = get_params(
m,
outfile,
polt,
signal_label,
)
# Title
if _title["stddev"]:
ttl = _title["param"] + r"$_{\mathrm{" + _title[
"comp"] + "}}^{\sigma}$"
elif _title["mean"]:
ttl = r"$\langle$" + _title[
"param"] + r"$\rangle$" + r"$_{\mathrm{" + _title[
"comp"] + "}}^{ }$"
elif _title["diff"]:
ttl = r"$\Delta$ " + _title["param"] + r"$_{\mathrm{" + _title[
"comp"] + "}}^{" + _title["diff_label"] + "}$"
else:
ttl = _title["param"] + r"$_{\mathrm{" + _title[
"comp"] + "}}^{ }$"
# Left signal label
lttl = r"$" + _title["sig"] + "$"
if lttl == "$I$":
lttl = "$T$"
elif lttl == "$QU$":
lttl = "$P$"
#elif lttl == "$P$":
# ticks *= 2
# Tick bug fix
mn = ticks[0]
mx = ticks[-1]
if len(ticks) > 2:
mid = ticks[1:-1]
# Unit
unt = _title["unit"]
else:
ttl = ""
lttl = ""
unt = ""
ticks = [False, False]
cmp = "planck"
lgscale = False
# Scale map
m *= scale
# If range has been specified, set.
"""
if rng:
if rng == "auto":
if minmax:
mn = np.min(m)
mx = np.max(m)
else:
mn, mx = get_ticks(m, 97.5)
if min is False:
min = mn
if max is False:
max = mx
else:
rng = float(rng)
min = -rng
max = rng
ticks = [min, 0.0, max]
print("hihi",rng)
else:
print("pre", ticks, min, max)
# If min and max have been specified, set.
if min is not False:
ticks[0] = float(min)
if max is not False:
ticks[-1] = float(max)
"""
# If min and max have been specified, set.
if rng == "auto" and not auto:
print("Setting range from 97.5th percentile of data")
mn, mx = get_ticks(m, 97.5)
elif rng == "minmax":
print("Setting range from min to max of data")
mn = np.min(m)
mx = np.max(m)
else:
try:
if float(rng) > 0.0:
mn = -float(rng)
mx = float(rng)
ticks = [False, 0.0, False]
except:
pass
if min is False:
min = mn
else:
min = float(min)
if max is False:
max = mx
else:
max = float(max)
ticks[0] = min
ticks[-1] = max
if mid:
ticks = [min, *mid, max]
##########################
#### Plotting Params #####
##########################
# Upper right title
if not title:
title = ttl
# Upper left title
if not ltitle:
ltitle = lttl
# Unit under colorbar
if not unit:
unit = unt
# Image size - ratio is always 1/2
xsize = 2000
ysize = int(xsize / 2.0)
ticklabels = ticks
#######################
#### logscale #####
#######################
# Some maps turns on logscale automatically
# -logscale command overwrites this
if logscale == None:
logscale = lgscale
if logscale:
print("Applying logscale")
starttime = time.time()
m = np.log10(0.5 * (m + np.sqrt(4.0 + m * m)))
ticks = []
for i in ticklabels:
if i > 0:
ticks.append(np.log10(i))
elif i < 0:
ticks.append(-np.log10(abs(i)))
else:
ticks.append(i)
m = np.maximum(np.minimum(m, ticks[-1]), ticks[0])
print(
"Logscale",
(time.time() - starttime),
) if verbose else None
######################
#### COLOR SETUP #####
######################
# Chose colormap manually
if cmap == None:
# If not defined autoset or goto planck
cmap = cmp
if cmap == "planck":
from pathlib import Path
cmap = Path(__file__).parent / "parchment1.dat"
cmap = col.ListedColormap(np.loadtxt(cmap) / 255.0, "planck")
else:
try:
import cmasher
cmap = eval(f"cmasher.{cmap}")
except:
cmap = plt.get_cmap(cmap)
print(f"Colormap: {cmap.name}")
#######################
#### Projection? #####
#######################
theta = np.linspace(np.pi, 0, ysize)
phi = np.linspace(-np.pi, np.pi, xsize)
longitude = np.radians(np.linspace(-180, 180, xsize))
latitude = np.radians(np.linspace(-90, 90, ysize))
# project the map to a rectangular matrix xsize x ysize
PHI, THETA = np.meshgrid(phi, theta)
grid_pix = hp.ang2pix(nside, THETA, PHI)
######################
######## Mask ########
######################
if mask:
print(f"Masking using {mask}")
masked = True
# Apply mask
hp.ma(m)
m.mask = np.logical_not(hp.read_map(mask, field=polt))
# Don't know what this does, from paperplots by Zonca.
grid_mask = m.mask[grid_pix]
grid_map = np.ma.MaskedArray(m[grid_pix], grid_mask)
if mfill:
cmap.set_bad(mfill) # color of missing pixels
# cmap.set_under("white") # color of background, necessary if you want to use
# using directly matplotlib instead of mollview has higher quality output
else:
grid_map = m[grid_pix]
######################
#### Formatting ######
######################
from matplotlib.projections.geo import GeoAxes
class ThetaFormatterShiftPi(GeoAxes.ThetaFormatter):
"""Shifts labelling by pi
Shifts labelling from -180,180 to 0-360"""
def __call__(self, x, pos=None):
if x != 0:
x *= -1
if x < 0:
x += 2 * np.pi
return GeoAxes.ThetaFormatter.__call__(self, x, pos)
sizes = get_sizes(size)
for width in sizes:
print("Size: " + str(width))
height = width / 2.0
# Make sure text doesnt change with colorbar
height *= 1.275 if colorbar else 1
################
##### font #####
################
if width > 12.0:
fontsize = 8
elif width == 12.0:
fontsize = 7
else:
fontsize = 6
fig = plt.figure(figsize=(
cm2inch(width),
cm2inch(height),
), )
ax = fig.add_subplot(111, projection="mollweide")
# rasterized makes the map bitmap while the labels remain vectorial
# flip longitude to the astro convention
image = plt.pcolormesh(
longitude[::-1],
latitude,
grid_map,
vmin=ticks[0],
vmax=ticks[-1],
rasterized=True,
cmap=cmap,
shading='auto',
)
# graticule
ax.set_longitude_grid(60)
ax.xaxis.set_major_formatter(ThetaFormatterShiftPi(60))
if width < 10:
ax.set_latitude_grid(45)
ax.set_longitude_grid_ends(90)
################
### COLORBAR ###
################
if colorbar:
# colorbar
from matplotlib.ticker import FuncFormatter
cb = fig.colorbar(
image,
orientation="horizontal",
shrink=0.3,
pad=0.08,
ticks=ticks,
format=FuncFormatter(fmt),
)
# Format tick labels
print("Ticks: ", ticklabels)
ticklabels = [fmt(i, 1) for i in ticklabels]
cb.ax.set_xticklabels(ticklabels)
cb.ax.xaxis.set_label_text(unit)
cb.ax.xaxis.label.set_size(fontsize)
# cb.ax.minorticks_on()
cb.ax.tick_params(
which="both",
axis="x",
direction="in",
labelsize=fontsize,
)
cb.ax.xaxis.labelpad = 4 # -11
# workaround for issue with viewers, see colorbar docstring
cb.solids.set_edgecolor("face")
# remove longitude tick labels
ax.xaxis.set_ticklabels([])
# remove horizontal grid
ax.xaxis.set_ticks([])
ax.yaxis.set_ticklabels([])
ax.yaxis.set_ticks([])
plt.grid(True)
###################
## RIGHT TITLE ####
###################
plt.text(
6.0,
1.3,
r"%s" % title,
ha="center",
va="center",
fontsize=fontsize,
)
##################
## LEFT TITLE ####
##################
plt.text(
-6.0,
1.3,
r"%s" % ltitle,
ha="center",
va="center",
fontsize=fontsize,
)
##############
#### SAVE ####
##############
plt.tight_layout()
filetype = "png" if png else "pdf"
# Turn on transparency unless told otherwise
tp = False if white_background else True
##############
## filename ##
##############
print(f"Signal label: {signal_label}")
outfile = outfile.replace("_IQU_", "_")
outfile = outfile.replace("_I_", "_")
filename = []
filename.append(f"{str(int(fwhm))}arcmin") if fwhm > 0 else None
filename.append("cb") if colorbar else None
filename.append("masked") if masked else None
filename.append("nodip") if remove_dipole else None
filename.append("dark") if darkmode else None
filename.append(f"c-{cmap.name}")
nside_tag = "_n" + str(int(nside))
if nside_tag in outfile:
outfile = outfile.replace(nside_tag, "")
fn = outfile + f"_{signal_label}_w{str(int(width))}" + nside_tag
for i in filename:
fn += f"_{i}"
fn += f".{filetype}"
starttime = time.time()
if outdir:
fn = outdir + "/" + os.path.split(fn)[-1]
print(f"Output: {fn}")
plt.savefig(
fn,
bbox_inches="tight",
pad_inches=0.02,
transparent=tp,
format=filetype,
)
print(
"Savefig",
(time.time() - starttime),
) if verbose else None
plt.close()
print(
"Totaltime:",
(time.time() - totaltime),
) if verbose else None
min = tempmin
max = tempmax
title = temptitle
ltitle = temptitle
unit = tempunit
logscale = templogscale
cmap = tempcmap
def basic_comp_sep(components, instrument, data, nside=0, **minimize_kwargs):
""" Basic component separation
Parameters
----------
components: list
List storing the :class:`Component` s of the mixing matrix
instrument:
Object that provides the following as a key or an attribute.
- **frequency**
- **depth_i** or **depth_p** (optional, frequencies are inverse-noise
weighted according to these noise levels)
They can be anything that is convertible to a float numpy array.
data: ndarray or MaskedArray
Data vector to be separated. Shape *(n_freq, ..., n_pix).*
*...* can be
- absent or 1: temperature maps
- 2: polarization maps
- 3: temperature and polarization maps (see note)
Values equal to `hp.UNSEEN` or, if `MaskedArray`, masked values are
neglected during the component separation process.
nside:
For each pixel of a HEALPix map with this nside, the non-linear
parameters are estimated independently
Returns
-------
result: dict
It includes
- **param**: *(list)* - Names of the parameters fitted
- **x**: *(ndarray)* - ``x[i]`` is the best-fit (map of) the *i*-th
parameter
- **Sigma**: *(ndarray)* - ``Sigma[i, j]`` is the (map of) the
semi-analytic covariance between the *i*-th and the *j*-th parameter.
It is meaningful only in the high signal-to-noise regime and when the
*cov* is the true covariance of the data
- **s**: *(ndarray)* - Component amplitude maps
- **mask_good**: *(ndarray)* - mask of the entries actually used in the
component separation
Note
----
* During the component separation, a pixel is masked if at least one of
its frequencies is masked.
* If you provide temperature and polarization maps, they will constrain the
**same** set of parameters. In particular, separation is **not** done
independently for temperature and polarization. If you want an
independent fitting for temperature and polarization, please launch
>>> res_T = basic_comp_sep(component_T, instrument, data[:, 0], **kwargs)
>>> res_P = basic_comp_sep(component_P, instrument, data[:, 1:], **kwargs)
"""
instrument = standardize_instrument(instrument)
# Prepare mask and set to zero all the frequencies in the masked pixels:
# NOTE: mask are bad pixels
mask = _intersect_mask(data)
data = hp.pixelfunc.ma_to_array(data).copy()
data[..., mask] = 0 # Thus no contribution to the spectral likelihood
try:
data_nside = hp.get_nside(data[0])
except TypeError:
data_nside = 0
prewhiten_factors = _get_prewhiten_factors(instrument, data.shape,
data_nside)
A_ev, A_dB_ev, comp_of_param, x0, params = _A_evaluator(
components, instrument, prewhiten_factors=prewhiten_factors)
if len(x0) == 0:
A_ev = A_ev()
if prewhiten_factors is None:
prewhitened_data = data.T
else:
prewhitened_data = prewhiten_factors * data.T
# Component separation
if nside:
patch_ids = hp.ud_grade(np.arange(hp.nside2npix(nside)),
hp.npix2nside(data.shape[-1]))
res = alg.multi_comp_sep(A_ev, prewhitened_data, None, A_dB_ev,
comp_of_param, patch_ids, x0,
**minimize_kwargs)
else:
res = alg.comp_sep(A_ev, prewhitened_data, None, A_dB_ev,
comp_of_param, x0, **minimize_kwargs)
# Craft output
# 1) Apply the mask, if any
# 2) Restore the ordering of the input data (pixel dimension last)
res.params = params
res.s = res.s.T
res.s[..., mask] = hp.UNSEEN
res.chi = res.chi.T
res.chi[..., mask] = hp.UNSEEN
if 'chi_dB' in res:
for i in range(len(res.chi_dB)):
res.chi_dB[i] = res.chi_dB[i].T
res.chi_dB[i][..., mask] = hp.UNSEEN
if nside and len(x0) > 0:
x_mask = hp.ud_grade(mask.astype(float), nside) == 1.
res.x[x_mask] = hp.UNSEEN
res.Sigma[x_mask] = hp.UNSEEN
res.x = res.x.T
res.Sigma = res.Sigma.T
res.mask_good = ~mask
return res
def read_map(path, nside, unit=None, field=0, map_dist=None):
"""Wrapper of `healpy.read_map` for PySM data. This function also extracts
the units from the fits HDU and applies them to the data array to form an
`astropy.units.Quantity` object.
This function requires that the fits file contains a TUNIT key for each
populated field.
Parameters
----------
path : object `pathlib.Path`, or str
Path of HEALPix map to be read.
nside : int
Resolution at which to return map. Map is read in at whatever resolution
it is stored, and `healpy.ud_grade` is applied.
Returns
-------
map : ndarray
Numpy array containing HEALPix map in RING ordering.
"""
mpi_comm = None if map_dist is None else map_dist.mpi_comm
pixel_indices = None if map_dist is None else map_dist.pixel_indices
filename = utils.RemoteData().get(path)
if (mpi_comm is not None and mpi_comm.rank == 0) or (mpi_comm is None):
output_map = hp.read_map(filename, field=field, dtype=None)
dtype = output_map.dtype
# numba only supports little endian
if dtype.byteorder == ">":
dtype = dtype.newbyteorder()
# mpi4py has issues if the dtype is a string like ">f4"
if dtype == np.dtype(np.float32):
dtype = np.dtype(np.float32)
elif dtype == np.dtype(np.float64):
dtype = np.dtype(np.float64)
nside_in = hp.get_nside(output_map)
if nside < nside_in: # do downgrading in double precision
output_map = hp.ud_grade(output_map.astype(np.float64), nside_out=nside)
else:
output_map = hp.ud_grade(output_map, nside_out=nside)
output_map = output_map.astype(dtype, copy=False)
if unit is None:
unit = extract_hdu_unit(filename)
shape = output_map.shape
elif mpi_comm is not None and mpi_comm.rank > 0:
npix = hp.nside2npix(nside)
try:
ncomp = len(field)
except TypeError: # field is int
ncomp = 1
shape = npix if ncomp == 1 else (len(field), npix)
unit = ""
dtype = None
if mpi_comm is not None:
from mpi4py import MPI
dtype = mpi_comm.bcast(dtype, root=0)
unit = mpi_comm.bcast(unit, root=0)
node_comm = mpi_comm.Split_type(MPI.COMM_TYPE_SHARED)
mpi_type = MPI._typedict[dtype.char]
mpi_type_size = mpi_type.Get_size()
win = MPI.Win.Allocate_shared(
np.prod(shape) * mpi_type_size if node_comm.rank == 0 else 0,
mpi_type_size,
comm=node_comm,
)
shared_buffer, item_size = win.Shared_query(0)
assert item_size == mpi_type_size
shared_buffer = np.array(shared_buffer, dtype="B", copy=False)
node_shared_map = np.ndarray(buffer=shared_buffer, dtype=dtype, shape=shape)
# only the first MPI process in each node is in this communicator
rank_comm = mpi_comm.Split(0 if node_comm.rank == 0 else MPI.UNDEFINED)
if mpi_comm.rank == 0:
node_shared_map[:] = output_map
if node_comm.rank == 0:
rank_comm.Bcast(node_shared_map, root=0)
mpi_comm.barrier()
# code with broadcast to whole communicator
# if mpi_comm.rank > 0:
# output_map = np.empty(shape, dtype=dtype)
# mpi_comm.Bcast(output_map, root=0)
else: # without MPI node_shared_map is just another reference to output_map
node_shared_map = output_map
if pixel_indices is not None:
# make copies so that Python can release the full array
try: # multiple components
output_map = np.array(
[each[pixel_indices].copy() for each in node_shared_map]
)
except IndexError: # single component
output_map = node_shared_map[pixel_indices].copy()
if mpi_comm is not None:
del node_shared_map
del shared_buffer
win.Free()
gc.collect()
return u.Quantity(output_map, unit, copy=False)
def main(args):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
Npix = 128 ## WARNING: This is hard-coded because of the architecture of both CNN
glob_ra,glob_dec, _ = np.loadtxt(args.ptsourcefile ,unpack=True)
localsize =np.int_( glob_ra.shape[0]/nprocs ) ## WARNING: this MUST evenly divide!!!!!!
ra = glob_ra[slice( rank *localsize , (rank +1)* localsize)]
dec = glob_dec[slice( rank *localsize , (rank +1)* localsize)]
Nstacks= ra.shape [0]
if args.pol :
keys = ['T', 'Q', 'U']
inputmap = hp.read_map(args.hpxmap ,field=[0,1,2] )
else:
keys = ['T' ]
inputmap = [hp.read_map( args.hpxmap) ]
mask = np.zeros_like (inputmap[0] )
nside = hp.get_nside(inputmap)
size_im = {2048: 192. ,4096 : 64., 32 :360. }
beam =np.deg2rad( args.beamsize /60.)
Inpainter = HoleInpainter (args.method,
modeldir = args.checkpoint_dir,
verbose =args.debug )
for i in range(Nstacks):
sizepatch = size_im[nside]*1. /Npix/60.
header = set_header(ra[i],dec[i], sizepatch )
tht,phi = rd2tp(ra[i],dec[i])
vec = hp.ang2vec( theta = tht,phi =phi )
pixs = hp.query_disc(nside,vec,3* beam)
mask [pixs] = 1.
for k,j in zip(keys, range(len(inputmap)) ) :
fname = args.stackfile+k+'_{:.5f}_{:.5f}_masked.npy'.format(ra[i],dec[i] )
fname = args.stackfile
Inpainter.setup_input( fname )
predicted = Inpainter.exec ()
np.save(args.stackfile+k+'_{:.5f}_{:.5f}_inpainted.npy'.format(ra[i],dec[i] ), predicted)
maskmap = f2h (predicted ,header, nside )
inputmap[j][pixs] = inpaintedmap[pixs]
break
maps = np.concatenate(inputmap).reshape(hp.nside2npix(nside), len(inputmap))
reducmaps = np.zeros_like(maps)
globmask= np.zeros_like(mask)
comm.Allreduce(maps, reducmaps, op=MPI.SUM)
comm.Allreduce(mask, globmask , op=MPI.SUM)
if rank ==0 :
hp.write_map(args.inpaintedmap , [inputmap[k] *(1- globmask) + reducmaps[:,k] *globmask for k in range(len(inputmap))] )
comm.Barrier()
comm.Disconnect
def sample(self, src_ra, mean_mu, poisson=True):
r"""
Inject mean_mu (more below) events using rejection sampling from
the healpy src_map.
Events from MC are selected from the same declination band as the
sampled position because the detector acceptance is declination
dependent and only events from the same declination band are
representative for an event position at the same declination.
`src_ra` is kept as a dummy argument for compatibility but has
no effect.
Parameters
----------
mean_mu : float
Mean number of events to sample
poisson : bool
Use poisson fluctuations, otherwise sample exactly *mean_mu*.
(default: True)
Returns
--------
num : int
Number of events
sam_ev : iterator
Sampled events for each loop iteration, either as simple array or
as dictionary for each sample, having the same fields as exp.
"""
def assign_and_drop(sam_ev, inj_ra, inj_dec):
r"""
Assign sampled ra/dec positions and drop mc fields from
injected sample. This replaces the rotate function in the
PointSourceInjector class.
"""
# Assign sampled locations from src map.
sam_ev["ra"] = inj_ra
sam_ev["dec"] = inj_dec
# Drop MC fields from the injected events
mc_names = ['ow', 'trueDec', 'trueE', 'trueRa']
return drop_fields(sam_ev, mc_names)
# Here starts the generator part
while True:
# Sample mu_mean directly or get n_inj from a poisson distribution
# if poisson = True was given
n_inj = (self.random.poisson(mean_mu) if poisson else int(
np.around(mean_mu)))
# If no events should be sampled, return nothing
if n_inj < 1:
yield n_inj, None
continue
# Otherwise sample pixel indices from combined soruce map
inj_ind, _ = amp_hp.healpy_rejection_sampler(self.src_map, n=n_inj)
# Assign indices to healpy map coordinates
NSIDE = hp.get_nside(self.src_map)
inj_th, inj_phi = hp.pix2ang(NSIDE, inj_ind)
# Get equatorial coordinates for the injected signal
inj_dec, inj_ra = amp_hp.ThetaPhiToDecRa(inj_th, inj_phi)
# Temporary recarray to hold the sampled mc_arr events
sam_idx = np.empty((n_inj, ), dtype=self.mc_arr.dtype)
# Loop over injected evts, select MC evt from all given samples
# and fill it into inj.
for i, (_dec, ra) in enumerate(zip(inj_dec, inj_ra)):
# First get the zenith band per event with correct boundaries
# This is from psLLH _select_events()
dec = (np.pi - 2. * self._dec_bandwidth) / np.pi * _dec
min_dec = max(-np.pi / 2., dec - self._dec_bandwidth)
max_dec = min(+np.pi / 2., dec + self._dec_bandwidth)
# Pick a random event from the MC data in the dec band.
# Events are weighted using the _norm_w set up in _weight()
mask = np.logical_and(self.mc_arr["dec"] > min_dec,
self.mc_arr["dec"] < max_dec)
# Choose one event from mc_arr per sampled location
sam_idx[i] = np.random.choice(self.mc_arr,
size=1,
p=self._norm_w)
# When we use multiple samples, store injected events from each
# given sample seperately
enums = np.unique(sam_idx["enum"])
# Case if only one rec array (single sample) was given in fill()
if len(enums) == 1 and enums[0] < 0:
# Only one sample, just return recarray
sam_ev = np.copy(self.mc[enums[0]][sam_idx["idx"]])
# Assign sampled ra/dec to single output array
yield n_inj, assign_and_drop(sam_ev, inj_ra, inj_dec)
continue
# For multiple samples return each injected event in a dict
# indicating from which original sample it came
sam_ev = dict()
for enum in enums:
mask = (sam_idx["enum"] == enum)
idx = sam_idx[mask]["idx"]
sam_ev_i = np.copy(self.mc[enum][idx])
# Assign sampled ra/dec to each out array
sam_ev[enum] = assign_and_drop(sam_ev_i, inj_ra[mask],
inj_dec[mask])
yield n_inj, sam_ev
def test_satellite_scan(lmax=700,
mmax=2,
fwhm=43,
ra0=-10,
dec0=-57.5,
az_throw=50,
scan_speed=2.8,
hwp_mode=None,
alpha=45.,
beta=45.,
alpha_period=5400.,
beta_period=600.,
delta_az=0.,
delta_el=0.,
delta_psi=0.,
jitter_amp=1.0):
'''
Simulates a satellite scan strategy
using a random LCDM realisation and a 3 x 3 grid
of Gaussian beams pairs. Bins tods into maps and
compares to smoothed input maps (no pair-
differencing). MPI-enabled.
Keyword arguments
---------
lmax : int,
bandlimit (default : 700)
mmax : int,
assumed azimuthal bandlimit beams (symmetric in this example
so 2 would suffice) (default : 2)
fwhm : float,
The beam FWHM in arcmin (default : 40)
ra0 : float,
Ra coord of centre region (default : -10)
dec0 : float, (default : -57.5)
Ra coord of centre region
az_throw : float,
Scan width in azimuth (in degrees) (default : 50)
scan_speed : float,
Scan speed in deg/s (default : 1)
hwp_mode : str, None
HWP modulation mode, either "continuous",
"stepped" or None. Use freq of 1 or 1/10800 Hz
respectively (default : None)
'''
print('Simulating a satellite...')
mlen = 3 * 24 * 60 * 60 # hardcoded mission length
# Create LCDM realization
ell, cls = get_cls()
np.random.seed(25) # make sure all MPI ranks use the same seed
alm = hp.synalm(cls, lmax=lmax, new=True, verbose=True) # uK
sat = ScanStrategy(
mlen, # mission duration in sec.
external_pointing=True, # Telling code to use non-standard scanning
sample_rate=12.01, # sample rate in Hz
location='space') # Instrument at south pole
# Create a 3 x 3 square grid of Gaussian beams
sat.create_focal_plane(nrow=7, ncol=7, fov=15, lmax=lmax, fwhm=fwhm)
# calculate tods in two chunks
sat.partition_mission(0.5 * sat.nsamp)
# Allocate and assign parameters for mapmaking
sat.allocate_maps(nside=256)
scan_opts = dict(q_bore_func=sat.satellite_scan,
ctime_func=sat.satellite_ctime,
q_bore_kwargs=dict(),
ctime_kwargs=dict())
# Generate timestreams, bin them and store as attributes
sat.scan_instrument_mpi(alm,
verbose=1,
ra0=ra0,
dec0=dec0,
az_throw=az_throw,
nside_spin=256,
max_spin=mmax,
**scan_opts)
# Solve for the maps
maps, cond, proj = sat.solve_for_map(fill=np.nan, return_proj=True)
# Plotting
if sat.mpi_rank == 0:
print('plotting results')
cart_opts = dict(unit=r'[$\mu K_{\mathrm{CMB}}$]')
# plot rescanned maps
plot_iqu(maps,
'../scratch/img/',
'rescan_satellite',
sym_limits=[250, 5, 5],
plot_func=hp.mollview,
**cart_opts)
# plot smoothed input maps
nside = hp.get_nside(maps[0])
hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
maps_raw = hp.alm2map(alm, nside, verbose=False)
plot_iqu(maps_raw,
'../scratch/img/',
'raw_satellite',
sym_limits=[250, 5, 5],
plot_func=hp.mollview,
**cart_opts)
# plot difference maps
for arr in maps_raw:
# replace stupid UNSEEN crap
arr[arr == hp.UNSEEN] = np.nan
diff = maps_raw - maps
plot_iqu(diff,
'../scratch/img/',
'diff_satellite',
sym_limits=[1e-6, 1e-6, 1e-6],
plot_func=hp.mollview,
**cart_opts)
# plot condition number map
cart_opts.pop('unit', None)
plot_map(cond,
'../scratch/img/',
'cond_satellite',
min=2,
max=5,
unit='condition number',
plot_func=hp.mollview,
**cart_opts)
plot_map(proj[0],
'../scratch/img/',
'hits_satellite',
unit='Hits',
plot_func=hp.mollview,
**cart_opts)
def harmonic_ilc(components,
instrument,
data,
lbins=None,
weights=None,
iter=3):
""" Harmonic Internal Linear Combination
Parameters
----------
components: list or tuple of lists
`Components` of the mixing matrix. They must have no free parameter.
instrument:
Object that provides the following as a key or an attribute.
- **frequency**
- **fwhm** (arcmin) they are deconvolved before ILC
They can be anything that is convertible to a float numpy array.
data: ndarray or MaskedArray
Data vector to be separated. Shape ``(n_freq, ..., n_pix)``.
``...`` can be 1, 3 or absent. If 3, the separation is done independently
fot T, E and B.
Values equal to hp.UNSEEN or, if MaskedArray, masked values are
neglected during the component separation process.
lbins: array
It stores the edges of the bins that will have the same ILC weights.
If a multipole is not in a bin but is the alms, an independent bin
will be assigned to it
weights: array
If provided data are multiplied by the weights map before computing alms
Returns
-------
result : dict
It includes
- **W**: *(ndarray)* - ILC weights for each component and possibly
each index of the `...` dimension in the alms.
- **s**: *(ndarray)* - Component maps
- **cl_in**: *(ndarray)* - Spectra of the input alm
- **cl_out**: *(ndarray)* - Spectra of the output alm
- **fsky**: *(ndarray)* - The input fsky used to correct the cls
Note
----
* During the component separation, a pixel is masked if at least one of its
frequencies is masked.
* Output spectra are divided by the fsky. fsky is computed with the MASTER
formula if `weights` is provided, otherwise it is the fraction of unmasked
pixels
"""
instrument = standardize_instrument(instrument)
nside = hp.get_nside(data[0])
lmax = 3 * nside - 1
lmax = min(lmax, lbins.max())
n_comp = len(components)
if weights is not None:
assert not np.any(_intersect_mask(data) * weights.astype(bool)), \
"Weights are non-zero where the data is masked"
fsky = np.mean(weights**2)**2 / np.mean(weights**4)
else:
mask = _intersect_mask(data)
fsky = float(mask.sum()) / mask.size
logging.info('Computing alms')
try:
assert np.any(instrument.Beams)
except (AttributeError, AssertionError):
beams = None
else: # Deconvolve the beam
beams = instrument.Beams
alms = _get_alms(data, beams, lmax, weights, iter=iter)
logging.info('Computing ILC')
res = harmonic_ilc_alm(components, instrument, alms, lbins, fsky)
logging.info('Back to real')
alms = res.s
res.s = np.empty((n_comp, ) + data.shape[1:], dtype=data.dtype)
for c in range(n_comp):
res.s[c] = hp.alm2map(alms[c], nside)
return res
def scan_atacama(lmax=700,
mmax=5,
fwhm=40,
mlen=48 * 60 * 60,
nrow=3,
ncol=3,
fov=5.0,
ra0=[-10, 170],
dec0=[-57.5, 0],
el_min=45.,
cut_el_min=False,
az_throw=50,
scan_speed=1,
rot_period=0,
hwp_mode='continuous'):
'''
Simulates 48h of an atacama-based telescope with a 3 x 3 grid
of Gaussian beams pairs. Prefers to scan the bicep patch but
will try to scan the ABS_B patch if the first is not visible.
Keyword arguments
---------
lmax : int
bandlimit (default : 700)
mmax : int
assumed azimuthal bandlimit beams (symmetric in this example
so 2 would suffice) (default : 5)
fwhm : float
The beam FWHM in arcmin (default : 40)
mlen : int
The mission length [seconds] (default : 48 * 60 * 60)
nrow : int
Number of detectors along row direction (default : 3)
ncol : int
Number of detectors along column direction (default : 3)
fov : float
The field of view in degrees (default : 5.0)
ra0 : float, array-like
Ra coord of centre region (default : [-10., 85.])
dec0 : float, array-like
Ra coord of centre region (default : [-57.5, 0.])
el_min : float
Minimum elevation range [deg] (default : 45)
cut_el_min: bool
If True, excludes timelines where el would be less than el_min
az_throw : float
Scan width in azimuth (in degrees) (default : 10)
scan_speed : float
Scan speed in deg/s (default : 1)
rot_period : float
The instrument rotation period in sec
(default : 600)
hwp_mode : str, None
HWP modulation mode, either "continuous",
"stepped" or None. Use freq of 1 or 1/10800 Hz
respectively (default : continuous)
'''
# hardcoded mission length
# Create LCDM realization
ell, cls = get_cls()
np.random.seed(25) # make sure all MPI ranks use the same seed
alm = hp.synalm(cls, lmax=lmax, new=True, verbose=True) # uK
ac = ScanStrategy(
mlen, # mission duration in sec.
sample_rate=12.01, # sample rate in Hz
location='atacama') # Instrument at south pole
# Create a 3 x 3 square grid of Gaussian beams
ac.create_focal_plane(nrow=nrow, ncol=ncol, fov=fov, lmax=lmax, fwhm=fwhm)
# calculate tods in two chunks
ac.partition_mission(0.5 * ac.mlen * ac.fsamp)
# Allocate and assign parameters for mapmaking
ac.allocate_maps(nside=256)
# set instrument rotation
ac.set_instr_rot(period=rot_period)
# Set HWP rotation
if hwp_mode == 'continuous':
ac.set_hwp_mod(mode='continuous', freq=1.)
elif hwp_mode == 'stepped':
ac.set_hwp_mod(mode='stepped', freq=1 / (3 * 60 * 60.))
# Generate timestreams, bin them and store as attributes
ac.scan_instrument_mpi(alm,
verbose=2,
ra0=ra0,
dec0=dec0,
az_throw=az_throw,
nside_spin=256,
el_min=el_min,
cut_el_min=cut_el_min,
create_memmap=True)
# Solve for the maps
maps, cond = ac.solve_for_map(fill=np.nan)
# Plotting
if ac.mpi_rank == 0:
print('plotting results')
img_out_path = '../scratch/img/'
moll_opts = dict(unit=r'[$\mu K_{\mathrm{CMB}}$]')
# plot rescanned maps
plot_iqu(maps,
img_out_path,
'rescan_atacama',
sym_limits=[250, 5, 5],
plot_func=hp.mollview,
**moll_opts)
# plot smoothed input maps
nside = hp.get_nside(maps[0])
hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
maps_raw = hp.alm2map(alm, nside, verbose=False)
plot_iqu(maps_raw,
img_out_path,
'raw_atacama',
sym_limits=[250, 5, 5],
plot_func=hp.mollview,
**moll_opts)
# plot difference maps
for arr in maps_raw:
# replace stupid UNSEEN crap
arr[arr == hp.UNSEEN] = np.nan
diff = maps_raw - maps
plot_iqu(diff,
img_out_path,
'diff_atacama',
sym_limits=[1e-6, 1e-6, 1e-6],
plot_func=hp.mollview,
**moll_opts)
# plot condition number map
moll_opts.pop('unit', None)
plot_map(cond,
img_out_path,
'cond_atacama',
min=2,
max=5,
unit='condition number',
plot_func=hp.mollview,
**moll_opts)
# plot input spectrum
cls[3][cls[3] <= 0.] *= -1.
dell = ell * (ell + 1) / 2. / np.pi
plt.figure()
for i, label in enumerate(['TT', 'EE', 'BB', 'TE']):
plt.semilogy(ell, dell * cls[i], label=label)
plt.legend()
plt.ylabel(r'$D_{\ell}$ [$\mu K^2_{\mathrm{CMB}}$]')
plt.xlabel(r'Multipole [$\ell$]')
plt.savefig('../scratch/img/cls_atacama.png')
plt.close()
print("Results written to {}".format(os.path.abspath(img_out_path)))
def powerSpectrum(hMap,
mask=None,
theory=[],
fsCl=None,
nBins=51,
lRange=None,
plot=False,
path="./figures/tests/test_power.pdf",
save=True):
"""Compute the power spectrum of a healpix map.
"""
nSide = hp.get_nside(hMap)
if mask is not None:
hMap *= mask
# define ell bins
lMax = 3 * nSide - 1
if lRange is None:
lEdges = np.logspace(np.log10(1.), np.log10(lMax), nBins, 10.)
else:
lEdges = np.logspace(np.log10(lRange[0]), np.log10(lRange[-1]), nBins,
10.)
# Unbinned power spectrum
power = hp.anafast(hMap)
power = np.nan_to_num(power)
# corresponding ell values
ell = np.arange(len(power))
# Bin the power spectrum
Cl, lEdges, binIndices = stats.binned_statistic(ell,
power,
statistic='mean',
bins=lEdges)
# correct for fsky from the mask
if mask is not None:
fsky = np.sum(mask) / len(mask)
Cl /= fsky
# bin centers
lCen, lEdges, binIndices = stats.binned_statistic(ell,
ell,
statistic='mean',
bins=lEdges)
# when bin is empty, replace lCen by a naive expectation
lCenNaive = 0.5 * (lEdges[:-1] + lEdges[1:])
lCen[np.where(np.isnan(lCen))] = lCenNaive[np.where(np.isnan(lCen))]
# number of modes
Nmodes, lEdges, binIndices = stats.binned_statistic(ell,
2 * ell + 1,
statistic='sum',
bins=lEdges)
Nmodes = np.nan_to_num(Nmodes)
# 1sigma uncertainty on Cl
if fsCl is None:
sCl = Cl * np.sqrt(2)
else:
sCl = np.array(map(fsCl, lCen))
sCl /= np.sqrt(Nmodes)
sCl = np.nan_to_num(sCl)
if plot:
factor = lCen**2 # 1.
fig = plt.figure(0)
ax = fig.add_subplot(111)
#
ax.errorbar(lCen, factor * Cl, yerr=factor * sCl, c='b', fmt='.')
ax.errorbar(lCen, -factor * Cl, yerr=factor * sCl, c='r', fmt='.')
#
for f in theory:
L = np.logspace(np.log10(1.), np.log10(np.max(ell)), 201, 10.)
ClExpected = np.array(map(f, L))
ax.plot(L, L**2 * ClExpected, 'k')
#
ax.set_xscale('log', nonposx='clip')
ax.set_yscale('log', nonposy='clip')
#ax.set_xlim(1.e1, 4.e4)
#ax.set_ylim(1.e-5, 2.e5)
ax.set_xlabel(r'$\ell$')
#ax.set_ylabel(r'$\ell^2 C_\ell$')
ax.set_ylabel(r'$C_\ell$')
#
if save == True:
print "saving plot to " + path
fig.savefig(path, bbox_inches='tight')
# fig.clf()
else:
plt.show()
return lCen, Cl, sCl
def read_map(path, nside, unit=None, field=0, map_dist=None, dataurl=None):
"""Wrapper of `healpy.read_map` for PySM data. This function also extracts
the units from the fits HDU and applies them to the data array to form an
`astropy.units.Quantity` object.
This function requires that the fits file contains a TUNIT key for each
populated field.
Parameters
----------
path : object `pathlib.Path`, or str
Path of HEALPix map to be read.
nside : int
Resolution at which to return map. Map is read in at whatever resolution
it is stored, and `healpy.ud_grade` is applied.
Returns
-------
map : ndarray
Numpy array containing HEALPix map in RING ordering.
"""
mpi_comm = None if map_dist is None else map_dist.mpi_comm
pixel_indices = None if map_dist is None else map_dist.pixel_indices
if dataurl is None:
dataurl = DATAURL
# read map. Add `str()` operator in case dealing with `Path` object.
if os.path.exists(
str(path)): # Python 3.5 requires turning a Path object to str
filename = str(path)
else:
with data.conf.set_temp("dataurl", dataurl), data.conf.set_temp(
"remote_timeout", 30):
filename = data.get_pkg_data_filename(path)
# inmap = hp.read_map(filename, field=field, verbose=False)
if (mpi_comm is not None and mpi_comm.rank == 0) or (mpi_comm is None):
output_map = hp.read_map(filename,
field=field,
verbose=False,
dtype=None)
dtype = output_map.dtype
# numba only supports little endian
if dtype.byteorder == ">":
dtype = dtype.newbyteorder()
# mpi4py has issues if the dtype is a string like ">f4"
if dtype == np.dtype(np.float32):
dtype = np.dtype(np.float32)
elif dtype == np.dtype(np.float64):
dtype = np.dtype(np.float64)
nside_in = hp.get_nside(output_map)
if nside < nside_in: # do downgrading in double precision
output_map = hp.ud_grade(output_map.astype(np.float64),
nside_out=nside)
else:
output_map = hp.ud_grade(output_map, nside_out=nside)
output_map = output_map.astype(dtype, copy=False)
if unit is None:
unit = extract_hdu_unit(filename)
elif mpi_comm is not None and mpi_comm.rank > 0:
npix = hp.nside2npix(nside)
try:
ncomp = len(field)
except TypeError: # field is int
ncomp = 1
shape = npix if ncomp == 1 else (len(field), npix)
unit = ""
dtype = None
if mpi_comm is not None:
dtype = mpi_comm.bcast(dtype, root=0)
if mpi_comm.rank > 0:
output_map = np.empty(shape, dtype=dtype)
mpi_comm.Bcast(output_map, root=0)
unit = mpi_comm.bcast(unit, root=0)
if pixel_indices is not None:
# make copies so that Python can release the full array
try: # multiple components
output_map = np.array(
[each[pixel_indices].copy() for each in output_map])
except IndexError: # single component
output_map = output_map[pixel_indices].copy()
return u.Quantity(output_map, unit, copy=False)
def simulate_high_galactic_latitude_CO(self):
"""
Coadd High Galactic Latitude CO emission, simulated with MCMole3D.
"""
if self.run_mcmole3d:
import mcmole3d as cl
# params to MCMole
N = 40000
L_0 = 20.4 # pc
L_min = .3
L_max = 60.
R_ring = 5.8
sigma_ring = 2.7 # kpc
R_bulge = 3.
R_z = 10 # kpc
z_0 = 0.1
Em_0 = 240.
R_em = 6.6
model = "LogSpiral"
nside = self.nside
Itot_o, _ = cl.integrate_intensity_map(
self.planck_templatemap,
hp.get_nside(self.planck_templatemap),
planck_map=True,
)
Pop = cl.Cloud_Population(N, model, randseed=self.random_seed)
Pop.set_parameters(
radial_distr=[R_ring, sigma_ring, R_bulge],
typical_size=L_0,
size_range=[L_min, L_max],
thickness_distr=[z_0, R_z],
emissivity=[Em_0, R_em],
)
Pop()
if self.verbose:
Pop.print_parameters()
# project into Healpix maps
mapclouds = cl.do_healpy_map(
Pop,
nside,
highgalcut=np.deg2rad(90. -
self.theta_high_galactic_latitude_deg),
apodization="gaussian",
verbose=self.verbose,
)
Itot_m, _ = cl.integrate_intensity_map(mapclouds, nside)
# convert simulated map into the units of the Planck one
rescaling_factor = Itot_m / Itot_o
mapclouds /= rescaling_factor
hglmask = np.zeros_like(mapclouds)
# Apply mask to low galactic latitudes
listhgl = hp.query_strip(
nside,
np.deg2rad(90. + self.theta_high_galactic_latitude_deg),
np.deg2rad(90 - self.theta_high_galactic_latitude_deg),
)
hglmask[listhgl] = 1.
rmsplanck = self.planck_templatemap[listhgl].std()
rmssim = mapclouds[listhgl].std()
if rmssim == 0.:
belowplanck = 1.
else:
belowplanck = rmssim / rmsplanck
return mapclouds * hglmask / belowplanck
else:
mapclouds = self.read_map(
"co/mcmoleCO_HGL_{}.fits".format(self.template_nside),
field=self.line_index,
)
return mapclouds
def apply_so_mask(hpix_map, weight=True):
nside = hp.get_nside(hpix_map)
cut = np.logical_not(so_mask_fitting(nside))
hits = np.sqrt(so_mask_hits(nside))
masked = np.ma.masked_array(data=hpix_map, mask=cut, fill_value=hp.UNSEEN)
return masked
type=int,
default=None)
parser.add_argument('--map_type',
help='type of mat to display, EFLUX, FLUX, TS or SIG',
required=False,
type=str,
default='EFLUX')
args = parser.parse_args()
# Read map
hpx_ul = hp.read_map(args.map)
# Get nside
nside = hp.get_nside(hpx_ul)
print nside
# Get some meaningful limits for the color bar among the points which are larger than 0 and finite
idx = (hpx_ul > 0) & np.isfinite(hpx_ul)
if np.sum(idx) == 0: idx = (hpx_ul >= 0) & np.isfinite(hpx_ul)
# Use the provided percentiles
if args.min_percentile != 0:
mmin = np.percentile(hpx_ul[idx], args.min_percentile)
else:
mmin = hpx_ul[idx].min()
def main():
p = argparse.ArgumentParser(
description="Plot map with Mercator projection")
p.add_argument("fitsfile",
nargs="*",
help="Input HEALPix FITS file. "
"To plot the weighted sum of multiple files, put a list of "
"file weight file weight pairs.")
p.add_argument("-a",
"--abthresh",
default=None,
type=float,
help="Apply an absolute (lower/upper) threshold to the map")
p.add_argument("-c",
"--coords",
default="C",
help="C=equatorial (default), G=galactic")
p.add_argument("-C",
"--column",
dest="col",
default=0,
type=int,
help="FITS column in which healpix map resides")
p.add_argument(
"--file-diff",
dest="diff",
default="",
type=str,
help=
"FITS File to take the difference from (optional) otherwise uses positional argument"
)
p.add_argument("-D",
"--coldiff",
default=-1,
type=int,
help="FITS column in which healpix map to be subtracted "
"(if any) resides")
p.add_argument(
"--mjd",
default=None,
type=float,
help=
"MJD of the map. Will be plotted in J2000. Supersedes info in header")
p.add_argument("-l",
"--threshold",
type=float,
default=None,
help="Apply a lower threshold to the plot.")
p.add_argument(
"--norm-sqdeg",
dest="sqdeg",
action="store_true",
default=False,
help="Normalize values to square degree, according to nSides"
" (makes sense only certain kinds of maps)")
p.add_argument("--milagro",
action="store_true",
help="Use Milagro color scale")
p.add_argument(
"--contours",
dest="contours",
type=float,
nargs='*',
default=None,
help="plot contours. If --contourmap is provided, it will be"
" used instead of plotted map. If no contours are"
" provided, it will plot confidence intervals"
" (1, 2, 3 sigma CI). Else, absolute sigmas are used,"
" e.g. --contours 1 2 3 4 [sigma] --contours")
p.add_argument("--contourscolor",
nargs='*',
default=None,
help="Draw options for contours")
p.add_argument("--contoursstyle",
nargs='*',
default=None,
help="Draw options for contours")
p.add_argument("--contourswidth",
type=float,
nargs='*',
default=None,
help="Draw options for contours")
p.add_argument("--contourfile",
nargs='*',
default=None,
help="Draw contours from file with RA/Dec pairs")
p.add_argument("--gamma",
action="store_true",
help="Use GeV/TeV gamma-ray color scale")
p.add_argument("-L", "--label", default=None, help="Color bar label")
p.add_argument("--cross",
action="store_true",
help="Plot a cross at the center of the plot")
p.add_argument("--moon",
action="store_true",
dest="isMoon",
help="is in moon centered coordinates")
p.add_argument("-m",
"--min",
type=float,
default=None,
help="Plot minimum value")
p.add_argument("-M",
"--max",
type=float,
default=None,
help="Plot maximum value")
p.add_argument("-n",
"--ncolors",
type=int,
default=256,
help="Number of contours to use in the colormap")
p.add_argument("--nocolorbar",
dest="colorbar",
action="store_false",
help="Do not draw color bar.")
p.add_argument("--nofill",
action="store_true",
help="Do not draw fill plot with colors. "
"Useful for contours.")
p.add_argument(
"-o",
"--output",
default=None,
help="Output file name (optional). "
"If file name ends in .fits or .fit, save as a healpix map with the pixels outside the plot area set to hp.UNSEEN."
)
p.add_argument("-s",
"--scale",
type=float,
default=1.,
help="scale up or down values in map")
p.add_argument("--sun",
action="store_true",
dest="isSun",
help="is in Sun centered coordinates")
p.add_argument("--dpar",
type=float,
default=1.,
help="Interval in degrees between parallels")
p.add_argument("--dmer",
type=float,
default=1.,
help="Interval in degrees between meridians.")
p.add_argument('--sexagesimal',
action='store_true',
help='Display RA in hh:mm.')
p.add_argument("--nogrid",
action="store_true",
help="Do not plot gridlines.")
p.add_argument("--interpolation",
action='store_true',
help="Uses bilinear interpolation in data map.")
p.add_argument("--xsize",
type=int,
default=1000,
help="Number of X pixels, Y will be scaled acordingly.")
p.add_argument("-t",
"--ticks",
nargs="+",
type=float,
help="List of ticks for color bar, space-separated")
p.add_argument("-T", "--title", help="title of map")
p.add_argument("--squareaspect",
action='store_true',
help="Better Mercator X/Y ratio.")
p.add_argument("--dpi",
type=int,
default=300,
help="Change the dpi of the output")
p.add_argument("--preliminary",
action="store_true",
help="Add a watermark indicating the plot as preliminary")
p.add_argument("--onlystats",
action="store_true",
help="Exits after returning min, max and value at center. "
"If map is called 'flux', it will give the error if there "
"is a map called 'flux_error'")
# Mutually exclusive option to specify plot xy range OR center + WxH
argRange = p.add_mutually_exclusive_group(required=False)
argRange.add_argument("--xyrange",
type=float,
nargs=4,
help="Xmin Xmax Ymin Ymax plot range [degree]")
argRange.add_argument(
"--origin",
type=float,
nargs=4,
help="Central (x,y) coords + width + height [degree]")
# Plot P-Value instead of sigma, expects location and scale of
# a right-skewed Gumble distribution
p.add_argument("--gumbel",
type=float,
nargs=2,
help="Plot P-Value instead of significance. "
"Arguments: location and scale of right-skewed "
"Gumble distribution.")
# Download/plotting options for Fermi catalog sources
p.add_argument(
"--download-fermi",
dest="dfermi",
default=None,
help="Download Fermi FITS data from NASA and exit. Enter version number"
)
p.add_argument("--fermicat",
default=None,
help="Fermi xFGL catalog FITS file name")
p.add_argument("--fermicat-labels",
dest="fermicatLabels",
action="store_true",
help="Draw Fermi sources with labels.")
# plotting options for Fermi Healpix file
p.add_argument("--contourmap",
default=None,
help="Healpix map from which to grab contours.")
p.add_argument(
"--contourmapcoord",
default="G",
help=
"Coordinate system of contourmap. C=equatorial, G=galactic (default)")
# Download/plotting options for TeVCat sources
p.add_argument("--download-tevcat",
dest="dtevcat",
action="store_true",
help="Download data from tevcat.uchicago.edu and exit")
p.add_argument("--tevcat",
default=None,
help="Draw TeVCat sources using TeVCat ASCII file")
p.add_argument("--tevcat-labels",
dest="tevcatLabels",
action="store_true",
help="Draw TeVCat sources with labels.")
p.add_argument("--cat-labels-angle",
dest="catLabelsAngle",
default=90,
help="Oriantation of catalog labels.")
p.add_argument("--cat-labels-size",
dest="catLabelsSize",
default=8,
help="Size of catalog labels.")
# Highlight hotspots listed in an ASCII file
p.add_argument("--hotspots",
default=None,
help="Hotspot coordinates in an ASCII file")
p.add_argument("--hotspot-labels",
dest="hotspotLabels",
action="store_true",
help="Draw hotspots sources with labels.")
# Plot 2D Gaussian fit result listed in an ASCII file from fitMap.py
p.add_argument("--gaussfit",
default=None,
help="2D-Gaussian fit result in an ASCII file")
args = p.parse_args()
#Sanity checks
if (args.mjd is not None) and (not canPrecess):
print("Missing necessary packages to make precession")
raise SystemExit
if args.nofill:
# If we don't fill with colors, we don't plot the colorbar either
args.colorbar = False
# Download TeVCat
if args.dtevcat:
if haveTeVCat:
print("Fetching data from tevcat.uchicago.edu.")
tevcat = TeVCat.TeVCat()
return None
else:
print("Sorry, AERIE TeVCat python module is not available.")
raise SystemExit
# Downlaod Fermi catalog
if args.dfermi:
if haveFermi:
print("Fetching 2FGL catalog, version %s" % args.dfermi)
FGLCatalog.fetch_catalog(args.dfermi)
return None
else:
print("Sorry, AERIE Fermi python module is not available.")
raise SystemExit
# Start normal processing
fitsfile = args.fitsfile
if fitsfile == []:
print("Please specify an FITS file to plot.")
raise SystemExit
# Fill 2D array
xmin = -180.
xmax = 180.
ymax = 90
ymin = -90
if (args.xyrange):
xmin, xmax, ymin, ymax = args.xyrange
xC = (xmin + xmax) / 2.
yC = (ymin + ymax) / 2.
elif (args.origin):
xC, yC, w, h = args.origin
xmin = xC - 0.5 * w
xmax = xC + 0.5 * w
ymin = yC - 0.5 * h
ymax = yC + 0.5 * h
else:
print("Using default zoom window. "
"To customize the zoom window you must specify either "
"(xyrange) or (origin and width and height).")
if args.isMoon or args.isSun:
xmin += 180.
xmax += 180.
# Move to range expected by healpy
while xmin < -180:
xmin += 360
while xmin > 180:
xmin -= 360
while xmax < -180:
xmax += 360
while xmax > 180:
xmax -= 360
if xmax < xmin:
tmax = xmax
tmin = xmin
xmin = tmax
xmax = tmin
cxmin = xmin
cxmax = xmax
frot = 0.
if xmax > 90. and xmin < -90.:
frot = 180.
cxmin = xmax - 180.
cxmax = xmin + 180.
if args.origin:
while xC > 180:
xC -= 360
# Read in the skymap and mask out empty pixels
skymap, skymapHeader = hp.read_map(fitsfile[0], args.col, h=True)
if len(fitsfile) > 1:
skymap *= float(fitsfile[1])
# If fitsfile has more parameters, they should be "mapfile weight" pairs
for i in range(2, len(fitsfile), 2):
skymap2 = hp.read_map(fitsfile[i], args.col)
skymap2 *= float(fitsfile[i + 1])
skymap += skymap2
# remove naughty values
skymap[np.isnan(skymap)] = hp.UNSEEN
skymap *= args.scale
nside1 = hp.get_nside(skymap)
npix = hp.nside2npix(nside1)
if args.coldiff > -1:
if os.path.isfile(args.diff):
print("Taking difference with {0}".format(args.diff))
skymap2 = hp.read_map(args.diff, args.coldiff)
else:
print("No extra file provided, using same file as input")
skymap2 = hp.read_map(fitsfile[0], args.coldiff)
if len(fitsfile) > 1:
skymap2 *= float(fitsfile[1])
print("Subtracting column {0} from skymap...".format(args.coldiff))
skymap -= skymap2
# If fitsfile has more parameters, they should be "mapfile weight" pairs
for i in range(2, len(fitsfile), 2):
skymap2 = hp.read_map(fitsfile[i], args.coldiff)
skymap2 *= float(fitsfile[i + 1])
skymap -= skymap2
if (args.gumbel):
assert haveGumbel
gumbel_location, gumbel_scale = args.gumbel
gumbel = gumbel_r(loc=gumbel_location, scale=gumbel_scale)
skymap = gumbel.logsf(skymap) / log(10)
def inf_suppressor(x):
return x if np.isfinite(x) else 0.
inf_suppressor = np.vectorize(inf_suppressor)
skymap = inf_suppressor(skymap)
# Normalize value to square degree
if args.sqdeg:
pixsizestr = 4 * np.pi / (12 * nside1**2)
str2sqdeg = (180 / np.pi)**2
pixsizesqdeg = pixsizestr * str2sqdeg
skymap /= pixsizesqdeg
# I did not find header handler, thats all I came up with...
toFind = 'TTYPE' + str(args.col + 1)
#print type(skymapHeader), type(skymapHeader[0]), skymapHeader, toFind, dict(skymapHeader)[toFind]
skymapName = dict(skymapHeader)[toFind]
#Check if it is flux
isFlux = False
hasFluxError = False
if skymapName == 'flux':
isFlux = True
keyname = dict((v, n) for n, v in skymapHeader).get("flux_error")
if keyname is not None:
if keyname.find('TTYPE') == 0 and len(keyname) == 6:
hasFluxError = True
fluxerrmap = hp.read_map(fitsfile[0], int(keyname[5]) - 1)
if not hasFluxError:
print("Map called 'flux_error' not present, will not print errors")
isFluxError = False
if skymapName == "flux_error":
isFluxError = True
# Find FOV
pxls = np.arange(skymap.size)
nZeroPix = pxls[(skymap != 0)]
pxTh, pxPh = hp.pix2ang(nside1, pxls)
# Mask outside FOV
values = np.ma.masked_where((pxTh > pxTh[nZeroPix].max())
| (pxTh < pxTh[nZeroPix].min())
| (skymap == hp.UNSEEN)
| (skymap == 1e20), skymap)
# Plot the skymap as an image, setting up the color palette on the way
mpl.rc("font", size=14, family="serif")
faspect = abs(cxmax - cxmin) / abs(ymax - ymin)
fysize = 4
# Set up the figure frame and coordinate rotation angle
coords = ["C", "C"]
gratcoord = "C"
if args.coords == "G":
coords = ["C", "G"]
gratcoord = "G"
if args.mjd is not None:
rotMap = precess.mjd2J2000ang(mjd=args.mjd, coord=coords, rot=frot)
rotVertex = precess.mjd2J2000ang(mjd=args.mjd, coord=coords)
elif not (args.isMoon or args.isSun):
mjd = False
if havePyfits:
hdulist = pf.open(fitsfile[0])
header = hdulist[0].header
if 'EPOCH' in header:
epoch = header['EPOCH']
if epoch == 'J2000':
pass
elif epoch == 'current':
if 'STARTMJD' in header and 'STOPMJD' in header:
startmjd = header['STARTMJD']
stopmjd = header['STOPMJD']
if (startmjd > 0
and stopmjd > 0) or startmjd > stopmjd:
mjd = (stopmjd + startmjd) / 2
else:
print(
"STARTMJD/STOPMJD are not well-definned, will not attempt to precess!"
)
else:
print(
"STARTMJD or STOPMJD not present in header, will not attempt to precess!"
)
else:
print(
"Currently EPOCH can be J2000 or current. Will not attempt to precess"
)
else:
print("Key EPOCH not in header, will not attempt to precess!")
else:
print(
"Pyfits not available -> Can't check map epoch -> Will not attempt to precess!"
)
if mjd:
print(
"Current epoch detected in header, will precess from MJD%g to J2000"
% mjd)
rotMap = precess.mjd2J2000ang(mjd=mjd, coord=coords, rot=frot)
rotVertex = precess.mjd2J2000ang(mjd=mjd, coord=coords)
else:
rotMap = frot
rotVertex = 0
else:
rotMap = frot
rotVertex = 0
# Get extrema
angverts = [[xmin,ymin],[xmax,ymin],\
[xmax,ymax],[xmin,ymax]]
vertlist = []
cRot = hp.Rotator(coord=coords, rot=rotVertex)
for x, y in angverts:
ctht, cph = np.deg2rad((y, x))
ctht = 0.5 * np.pi - ctht
if cph < 0:
cph = 2. * np.pi + cph
vertlist.append(cRot.I(hp.ang2vec(ctht, cph)))
# Get pixels in image
imgpix = hp.query_polygon(nside1, vertlist, inclusive=True)
seenpix = imgpix[values[imgpix] > hp.UNSEEN]
#if output is fits file: clip input healpy map by setting all pixels outside the plotted area to UNSEEN,
#then save the result.
if args.output and (args.output.endswith(".fits")
or args.output.endswith(".fit")):
pix = np.ones(npix, dtype=bool)
pix[seenpix] = False
values[pix] = hp.UNSEEN
print("Saving clipped healpy map to %s" % args.output)
hp.write_map(args.output,
values,
partial=True,
column_names=[skymapName])
exit()
#Get stats
precRot = hp.Rotator(coord=coords, rot=rotVertex)
pixMin, pixMax = seenpix[[
np.argmin(values[seenpix]),
np.argmax(values[seenpix])
]]
dMin, dMax = values[[pixMin, pixMax]]
[[thMin, thMax],
[phMin, phMax]] = np.rad2deg(precRot(hp.pix2ang(nside1,
[pixMin, pixMax])))
if args.coords == 'C':
while phMin < 0:
phMin += 360
while phMax < 0:
phMax += 360
th0, ph0 = precRot.I((90. - yC) * degree, xC * degree)
pix0 = hp.ang2pix(nside1, th0, ph0)
if isFlux:
if hasFluxError:
fluxerrMin, fluxerrMax, fluxerr0 = fluxerrmap[[
pixMin, pixMax, pix0
]]
else:
fluxerrMin, fluxerrMax, fluxerr0 = [0, 0, 0]
print("Flux units: TeV^-1 cm^-2 s^-1")
print("Coord units: deg")
print("Min: %11.2e +/- %11.2e (%6.2f, %5.2f)" %
(dMin, fluxerrMin, phMin, 90 - thMin))
print("Max: %11.2e +/- %11.2e (%6.2f, %5.2f)" %
(dMax, fluxerrMax, phMax, 90 - thMax))
print("Map value at origin: %11.2e +/- %11.2e" %
(skymap[pix0], fluxerr0))
elif isFluxError:
print("Min: %5.4e (%6.2f, %5.2f)" %
(dMin, phMin, 90 - thMin))
print("Max: %5.4e (%6.2f, %5.2f)" %
(dMax, phMax, 90 - thMax))
print("Map value at origin: %5.4e" % skymap[pix0])
else:
print("Min: %5.2f (%6.2f, %5.2f)" %
(dMin, phMin, 90 - thMin))
print("Max: %5.2f (%6.2f, %5.2f)" %
(dMax, phMax, 90 - thMax))
print("Map value at origin: %5.2f" % skymap[pix0])
if args.onlystats:
return 0
figsize = (fysize * faspect + 2, fysize + 2.75)
fig = plt.figure(num=1, figsize=figsize)
# Set min/max value of map
if args.min is not None:
dMin = args.min
values[(skymap < dMin) & (values > hp.UNSEEN)] = dMin
if args.max is not None:
dMax = args.max
values[(skymap > dMax) & (values > hp.UNSEEN)] = dMax
textcolor, colormap = MapPalette.setupDefaultColormap(args.ncolors)
# Use the Fermi/HESS/VERITAS purply-red-yellow color map
if args.gamma:
textcolor, colormap = MapPalette.setupGammaColormap(args.ncolors)
# Use the Milagro color map
if args.milagro:
dMin = -5
dMax = 15
dMin = args.min if args.min != None else -5
dMax = args.max if args.max != None else 15
thresh = args.threshold if args.threshold != None else 2.
textcolor, colormap = \
MapPalette.setupMilagroColormap(dMin, dMax, thresh, args.ncolors)
print("Milagro", dMin, dMax, thresh)
# Use a thresholded grayscale map with colors for extreme values
else:
if args.threshold != None:
textcolor, colormap = \
MapPalette.setupThresholdColormap(dMin, dMax, args.threshold,
args.ncolors)
elif args.abthresh != None:
textcolor, colormap = \
MapPalette.setupAbsThresholdColormap(dMin, dMax, args.abthresh,
args.ncolors)
if args.interpolation:
cRot = hp.Rotator(rot=rotMap, coord=coords)
phi = np.linspace(np.deg2rad(xmax), np.deg2rad(xmin), args.xsize)
if xmin < 0 and xmax > 0 and (xmax - xmin) > 180.:
phi = np.linspace(
np.deg2rad(xmin) + 2. * np.pi, np.deg2rad(xmax), args.xsize)
phi[(phi > 2. * np.pi)] -= 2. * np.pi
theta = 0.5 * np.pi - np.linspace(np.deg2rad(ymin), np.deg2rad(ymax),
args.xsize / faspect)
Phi, Theta = np.meshgrid(phi, theta)
rTheta,rPhi = cRot.I(Theta.reshape(phi.size*theta.size),\
Phi.reshape(phi.size*theta.size))
rotimg = hp.get_interp_val(values, rTheta.reshape(Phi.shape),\
rPhi.reshape(Theta.shape))
else:
tfig = plt.figure(num=2, figsize=figsize)
rotimg = hp.cartview(values, fig=2,coord=coords,title="",\
cmap=colormap, cbar=False,\
lonra=[cxmin,cxmax],latra=[ymin,ymax],rot=rotMap,
notext=True, xsize=args.xsize,
return_projected_map=True)
plt.close(tfig)
ax = fig.add_subplot(111)
ax.set_aspect(1.)
# if plotting contours
if args.contours != None:
if args.contourmap:
contourmap = args.contourmap
contourmapcoord = args.contourmapcoord
else:
contourmap = fitsfile[0]
contourmapcoord = 'C'
contourSkyMap, contourSkyMapHeader = hp.read_map(contourmap, h=True)
fnside1 = hp.get_nside(contourSkyMap)
ftoFind = 'TTYPE' + str(1)
contourSkyMapName = dict(contourSkyMapHeader)[ftoFind]
#<<<<<<< .mine
# fvalues = contourSkyMap #np.ma.masked_where(contourSkyMap == 0, contourSkyMap)
#=======
#>>>>>>> .r38901
if args.interpolation:
cRot = hp.Rotator(rot=rotMap, coord=[contourmapcoord, coords[-1]])
phi = np.linspace(np.deg2rad(xmax), np.deg2rad(xmin), args.xsize)
if xmin < 0 and xmax > 0 and (xmax - xmin) > 180.:
phi = np.linspace(
np.deg2rad(xmin) + 2. * np.pi, np.deg2rad(xmax),
args.xsize)
phi[(phi > 2. * np.pi)] -= 2. * np.pi
theta = 0.5 * np.pi - np.linspace(
np.deg2rad(ymin), np.deg2rad(ymax), args.xsize / faspect)
Phi, Theta = np.meshgrid(phi, theta)
rTheta,rPhi = cRot.I(Theta.reshape(phi.size*theta.size),\
Phi.reshape(phi.size*theta.size))
frotimg = hp.get_interp_val(contourSkyMap,rTheta.reshape(Phi.shape),\
rPhi.reshape(Theta.shape))
else:
tfig = plt.figure(num=3, figsize=figsize)
frotimg = hp.cartview(contourSkyMap,
fig=3,
coord=[contourmapcoord, coords[-1]],
title="",
cmap=colormap,
cbar=False,
lonra=[xmin, xmax],
latra=[ymin, ymax],
rot=rotMap,
notext=True,
xsize=1000,
min=dMin,
max=dMax,
return_projected_map=True)
plt.close(tfig)
if args.contours == []:
rMaxSig2 = (contourSkyMap[imgpix].max())**2
if rMaxSig2 < 11.83:
print(
"No spot detected with at least a 3sigma confidence contour"
)
contours = [-float("inf")]
else:
contours = [
sqrt(rMaxSig2 - 2.30),
sqrt(rMaxSig2 - 6.18),
sqrt(rMaxSig2 - 11.83)
]
else:
contours = args.contours
ccolor = args.contourscolor or 'g'
cstyle = args.contoursstyle or '-'
cwidth = args.contourswidth or 2.
print('Contours style: ', ccolor, cstyle, cwidth)
contp = ax.contour(frotimg,
levels=np.sort(contours),
colors=ccolor,
linestyles=cstyle,
linewidths=cwidth,
origin='upper',
extent=[cxmax, cxmin, ymax, ymin])
rotimg[(rotimg > dMax)] = dMax
rotimg[(rotimg < dMin)] = dMin
if not args.nofill:
imgp = ax.imshow(rotimg,extent=[cxmax, cxmin, ymax, ymin],\
vmin=dMin,vmax=dMax,cmap=colormap)
imgp.get_cmap().set_under('w', alpha=0.)
imgp.get_cmap().set_over('w', alpha=0.)
#User defined contour
if args.contourfile is not None:
ccolor = args.contourscolor or ['g']
cstyle = args.contoursstyle or ['-']
cwidth = args.contourswidth or [2.]
if len(ccolor) == 1:
ccolor = np.repeat(ccolor[0], len(args.contourfile))
if len(cstyle) == 1:
cstyle = np.repeat(cstyle[0], len(args.contourfile))
if len(cwidth) == 1:
cwidth = np.repeat(cwidth[0], len(args.contourfile))
for i, f in enumerate(args.contourfile):
ra, dec = np.loadtxt(f, unpack=True)
if xmax > 90. and xmin < -90.:
#Map at the discontinuity boundary
ra -= 180
ra[ra > 180] -= 360
ra[ra < -180] += 360
ax.plot(ra,
dec,
color=ccolor[i],
linestyle=cstyle[i],
linewidth=cwidth[i])
# Draw grid lines
xts = np.arange(np.floor(xmin), np.ceil(xmax + args.dmer), args.dmer)[1:-1]
xtlbs = [
'%g' % (xt + 360) if args.coords == 'C' and xt < 0 else '%g' % xt
for xt in xts
]
if xmin < 0. and xmax > 0. and (xmax - xmin) > 180.:
xts = np.arange(np.floor(cxmin), np.ceil(cxmax + args.dmer),
args.dmer)[1:-1]
xtlbs = []
for xt in xts:
cval = xt - 180.
if xt < 0:
cval = 180. + xt
if cval == -180:
cval = 180
if args.isMoon or args.isSun:
cval -= 180.
if cval < -180.:
cval += 360.
elif args.coords == 'C' and cval < 0:
cval += 360
xtlbs.append('%g' % (cval))
yts = np.arange(np.floor(ymin), np.ceil(ymax + args.dpar), args.dpar)[1:-1]
if args.nogrid == False:
ax.grid(color=textcolor)
ax.xaxis.set_ticks(xts)
ax.xaxis.set_ticklabels(xtlbs)
ax.yaxis.set_ticks(yts)
if args.preliminary:
plt.text((xmin + xmax) / 2.,
ymin + 0.85 * (ymax - ymin),
"PRELIMINARY",
color=textcolor,
alpha=0.8,
fontdict={
"family": "sans-serif",
"weight": "bold",
"size": 28
},
horizontalalignment='center')
# If TeVCat data are available, plot them
if args.tevcat or args.tevcatLabels:
if haveTeVCat:
try:
if args.tevcat:
tevcat = TeVCat.TeVCat(args.tevcat)
elif args.tevcatLabels:
tevcat = TeVCat.TeVCat(args.tevcatLabels)
except IOError as e:
print(e)
print("Downloading data from tevcat.uchicago.edu")
tevcat = TeVCat.TeVCat()
except:
print("Why caught here?")
print("Downloading data from tevcat.uchicago.edu")
tevcat = TeVCat.TeVCat()
cRot = hp.Rotator(coord=["C", coords[-1]])
tnside = 512
fpix = np.zeros(hp.nside2npix(tnside))
for cId in (1, 2):
catalog = tevcat.GetCatalog(cId)
ra = catalog.GetRA()
dec = catalog.GetDec()
assoc = catalog.GetCanonicalName()
cut = (assoc != 'Crab Pulsar')
ra = ra[cut]
dec = dec[cut]
assoc = assoc[cut]
cpix = hp.ang2pix(tnside, np.pi * 0.5 - dec, ra)
slpx = []
for sx, px in enumerate(cpix):
fpix[px] += 1
if fpix[px] != 1:
print("%s is a duplicate" % (assoc[sx]))
slpx.append(sx)
ra = np.delete(ra, slpx)
dec = np.delete(dec, slpx)
assoc = np.delete(assoc, slpx)
y, x = cRot(np.pi * 0.5 - dec, ra)
x = np.rad2deg(x) + frot
x[(x > 180.)] -= 360.
y = 90. - np.rad2deg(y)
cut = (x > xmin) & (x < xmax) & (y > ymin) & (y < ymax)
x = x[cut]
y = y[cut]
assoc = assoc[cut]
ax.scatter(x,
y,
color=textcolor,
facecolors="none",
marker="s")
if args.tevcatLabels:
for r, d, s in zip(x, y, assoc):
print(r, d, s)
ax.text(r,
d,
s + ' .',
color=textcolor,
rotation=args.catLabelsAngle,
fontdict={
'family': 'sans-serif',
'size': args.catLabelsSize,
'weight': 'bold'
})
else:
print("Sorry, TeVCat could not be loaded.")
# If Fermi data are available, plot them
if args.fermicat:
if haveFermi:
fcat = None
try:
fcat = FGLCatalog.FGLCatalog(args.fermicat)
aflag = fcat.GetAnalysisFlags()
acut = (aflag == 0) # cut analysis errors
flux = fcat.GetFlux1000() # 1-100 GeV flux
dflx = fcat.GetFlux1000Error() # flux uncertainty
fcut = dflx / flux < 0.5 # cut poorly measured srcs
cuts = np.logical_and(acut, fcut)
print('Using FGL')
except:
try:
fcat = FHLCatalog.FHLCatalog(args.fermicat)
cuts = (fcat.GetFlux() > 0.) # Dummy cut
print('Using FHL')
except:
print('Fermi catalog could not be loaded!')
if fcat != None:
# Don't show TeV associations if plotting from TeVCat
if args.tevcat or args.tevcatLabels:
tcfg = fcat.GetTeVCatFlag()
tcut = (tcfg == "N") | (tcfg == "C")
cuts = np.logical_and(cuts, tcut)
ra = fcat.GetRA()[cuts]
dec = fcat.GetDec()[cuts]
assoc = fcat.GetSourceName()[cuts]
catnms = fcat.GetCatalogName()[cuts]
for i in xrange(len(assoc)):
if assoc[i] == '':
assoc[i] = catnms[i]
cRot = hp.Rotator(coord=["C", coords[-1]])
y, x = cRot(np.pi * 0.5 - dec, ra)
x = np.rad2deg(x) + frot
x[(x > 180.)] -= 360.
y = 90. - np.rad2deg(y)
cut = (x > xmin) & (x < xmax) & (y > ymin) & (y < ymax)
x = x[cut]
y = y[cut]
assoc = assoc[cut]
ax.scatter(x, y, color=textcolor, facecolors="none", marker="o")
if args.fermicatLabels:
for r, d, s in zip(x, y, assoc):
ax.text(r,
d,
s,
color=textcolor,
rotation=args.catLabelsAngle,
fontdict={
'family': 'sans-serif',
'size': args.catLabelsSize,
'weight': 'bold'
})
else:
print("Sorry, the Fermi xFGL catalog could not be loaded.")
# If a hotspot list is given, plot it
if args.hotspots:
fhot = open(args.hotspots, "r")
ra = []
dec = []
assoc = []
for line in fhot:
if line.startswith("#"):
continue
larr = line.strip().split()
ra.append(float(larr[1]))
dec.append(float(larr[2]))
assoc.append(larr[4])
ra = np.deg2rad(ra)
dec = np.deg2rad(dec)
assoc = np.array(assoc)
cRot = hp.Rotator(coord=["C", coords[-1]])
y, x = cRot(np.pi * 0.5 - dec, ra)
x = np.rad2deg(x) + frot
x[(x > 180.)] -= 360.
y = 90. - np.rad2deg(y)
cut = (x > xmin) & (x < xmax) & (y > ymin) & (y < ymax)
x = x[cut]
y = y[cut]
assoc = assoc[cut]
ax.scatter(x, y, color=textcolor, facecolors="none", marker="o")
if args.hotspotLabels:
for r, d, s in zip(x, y, assoc):
print(r, d, s)
ax.text(r,
d,
s + ' .',
color=textcolor,
rotation=90,
fontdict={
'family': 'sans-serif',
'size': 8,
'weight': 'bold'
})
# If a gaussian fit file is given, plot it
if args.gaussfit:
gfit = open(args.gaussfit, "r")
gfit.next()
gfit.next()
ra, raErr = [float(i) for i in gfit.next().strip().split()]
dec, decErr = [float(i) for i in gfit.next().strip().split()]
raW, raWErr = [float(i) for i in gfit.next().strip().split()]
decW, decWErr = [float(i) for i in gfit.next().strip().split()]
gfit.close()
mrot = -180. if args.isMoon or args.isSun else 0.
cRot = hp.Rotator(coord=["C", coords[-1]])
y, x = cRot(np.pi * 0.5 - np.deg2rad(dec), np.deg2rad(ra + mrot))
x = np.rad2deg(x) + frot
x = x - 360. if x > 180. else x
y = 90. - np.rad2deg(y)
ellip0 = Ellipse((x, y),
width=2 * raW,
height=2 * decW,
edgecolor='black',
facecolor='None')
ax.add_patch(ellip0)
ax.scatter(x, y, s=20, color='black', facecolors="black", marker="o")
print(x, y, xmin, xmax, ymin, ymax)
ax.text(
x - 1,
y + 1,
"%s=%.02f$\pm$%.02f\n$\Delta\delta$=%.02f$\pm$%.02f\n%s=%.02f$\pm$%.02f\n$\sigma_\delta$=%.02f$\pm$%.02f"
% (r"$\Delta\alpha$", ra, raErr, dec, decErr, r"$\sigma_\alpha$",
raW, raWErr, decW, decWErr),
color=textcolor,
rotation=0,
fontdict={"size": 12})
# Set up the color bar
# Setup color tick marks
if args.colorbar:
cticks = args.ticks
if args.ticks == None:
if (dMax - dMin) > 3:
clrmin = np.floor(dMin)
clrmax = np.ceil(dMax)
ctspc = np.round((clrmax - clrmin) / 10.)
if ctspc == 0.:
ctspc = 1.
if clrmin < 0 and clrmax > 0:
cticks = -np.arange(0, -clrmin, ctspc)
cticks = np.sort(
np.unique(
np.append(cticks, np.arange(0, clrmax, ctspc))))
else:
cticks = np.arange(clrmin, clrmax + ctspc, ctspc)
else:
cticks = None
cb = fig.colorbar(
imgp,
orientation="horizontal",
shrink=0.85,
fraction=0.1,
#aspect=25,
pad=0.1,
ax=ax,
ticks=cticks)
if args.label:
skymapName = args.label
else:
if re.match("significance", skymapName):
skymapName = r"significance [$\sigma$]"
if args.gumbel:
skymapName = "log10(P-Value)"
if args.colorbar:
cb.set_label(skymapName)
xUnit = " [$^\circ$]"
if args.sexagesimal:
xUnit = ""
yUnit = " [$^\circ$]"
xlabel = r"$\alpha$%s" % xUnit
ylabel = r"$\delta$%s" % yUnit
# Set up the color bar and tick axis
if args.coords == "G":
xlabel = r"$l$%s" % xUnit
ylabel = r"$b$%s" % yUnit
if args.isMoon or args.isSun:
xlabel = r"$\Delta\alpha$%s" % xUnit
ylabel = r"$\Delta\delta$%s" % yUnit
# X axis label
ax.set_xlabel(xlabel, color='k')
# Y axis label
ax.set_ylabel(ylabel, color='k')
if args.sexagesimal:
if haveAstropy:
# Display RA with hh:mm nonsense.
ticksLocationsRA = plt.xticks()[0]
def degrees_to_hhmmss(ra):
return Angle(ra, u.degree).to_string(unit=u.hour, fields=2)
ticksLabelsRA = degrees_to_hhmmss(ticksLocationsRA)
plt.xticks(ticksLocationsRA, ticksLabelsRA)
# The same with DEC coordinates. Actually no, we never plot less than 1 degree...
if False:
ticksLocationsDEC = plt.yticks()[0]
def degrees_to_ddmmss(dec):
return Angle(dec, u.degree).to_string(unit=u.degree,
fields=2)
ticksLabelsDEC = degrees_to_ddmmss(ticksLocationsDEC)
plt.yticks(ticksLocationsDEC, ticksLabelsDEC)
else:
print('Error: "--sexagesimal" ignored (needs astropy module)')
# Title
if args.title != None:
ax.set_title(r"{0}".format(args.title.replace("\\n", "\n")), color='k')
if args.cross:
# Indicate the center of the plot with a thick black cross
ax.scatter(xC,
yC,
s=20**2,
marker="+",
facecolor="#000000",
color="#000000")
ax.set_ylim(ymin, ymax)
ax.set_xlim(cxmax, cxmin)
if args.squareaspect:
plt.axes().set_aspect(1. / cos((ymax + ymin) / 2 * pi / 180))
# Either output the image to a file and quit or plot it in a window
if args.output:
if not args.nofill:
fig.savefig(args.output, dpi=args.dpi)
else:
fig.savefig(args.output, dpi=args.dpi, transparent=True)
print("File %s created" % args.output)
else:
plt.show()
def test_load_signal_rescaling(self):
params = Struct(beam_nside=2**6)
ctx = Struct(params=params)
astro_signal = static_gsm.load_signal(ctx)
assert astro_signal is not None
assert hp.get_nside(astro_signal) == ctx.params.beam_nside
if args.taper_coords:
try:
ra0, dec0 = map(float, args.taper_coords.split(','))
except:
exit(
'Cannot convert --taper_coords into ra,dec - must be two numbers separated by a comma'
)
##Read in healpix map and get nside
##Convert in Jy if necessary
flux = hp.read_map(args.healpix)
if unit == 'mK' or unit == 'K':
flux = convert2Jy(flux, float(frequency), unit)
nside = hp.get_nside(flux)
##Find out ra,dec and convert to degrees
dec, ra = hp.pix2ang(nside, arange(hp.nside2npix(nside)))
dec = dec * (180. / pi) - 90.0
ra *= (180 / pi)
if args.taper_coords:
ra0, dec0 = map(float, args.taper_coords.split(','))
#if args.use_minimum_flux_as_floor:
#noise_floor = flux.min()
#print 'Noise floor is',noise_floor,flux.max()
#else:
#noise_floor = condon_fixbase(bmax=float(args.max_baseline),freq=float(frequency))
#if noise_floor <= 0:
temps[catalog[:, -1] == 1] = (
catalog[:, 3][catalog[:, -1] == 1] * 1e-9 * fluxfacs[j] *
fac) / np.square(np.radians(
catalog[:, 4][catalog[:, -1] == 1])) #Using GAUFLUX if EXTENDED
#catalog[:,2:] * fluxfacs[:,None].T * 0.001 #mK
sigmas = np.radians(catalog[:, 4] / 60.) / (
2. * mh.sqrt(2. * mh.log(2.))
) #np.radians(fwhms) / (2.*mh.sqrt(2.*mh.log(2.))) #sigma in radians
sigmas[catalog[:, -1] == 0] = fwhms_rad[j] / (
2. * mh.sqrt(2. * mh.log(2.))) #Use beamFWHM if not EXTENDED
for i in xrange(len(coords)): #Loop over point sources
print 'Subtracting Gaussian profile for point source', i + 1, '/', len(
coords), 'map', j
samppixs = hp.query_disc(hp.get_nside(maps[j]),
hp.ang2vec(coords[i, 1], coords[i, 0]),
5. * sigmas[i])
maps[j] = gauss_source(maps[j], temps[i], sigmas[i],
(coords[i, 1], coords[i, 0]), samppixs)
#samppixsall = np.concatenate((samppixsall,samppixs)) #Slows program down
#Save point source residuals
resid[j] = origmaps[j] - maps[j]
'''testmap = cp.deepcopy(maps[j])
testmap[:] = 0.
testmap[samppixsall[1:]] = 1.'''
#Write new maps to FITS files
for i in xrange(len(maps)):
hp.write_map(outfits[i], maps[i])
def BeamMap( pointRA=None, pointDec=None, dwl=None, freq=None, uniform=False, Bmap0=None, dtype='float32', nside=None ) : ''' pointRA, pointDec: [degree] Where does the antenna point to? default points to (RA, Dec) = (0, 0) dwl: [meter] d - diameter: for dish: one value w - width, l - length: for cylinder: (w,l) freq: [MHz] Used to get FWHM uniform: True | False If ==True: return =1 map Bmap0: Use this Bmap0 as the basic and rotate it to (pointRA, pointDec) ''' import healpy as hp import numpy as np from jizhipy.Array import Asarray from jizhipy.Basic import Raise from jizhipy.Transform import CoordTrans try : dtype = np.dtype(dtype) except : dtype = np.dtype(None) if (nside is not None) : nside = int(round(nside)) elif (Bmap0 is not None) : nside = hp.get_nside(Bmap0) else : Raise(Exception, 'nside = None') #-------------------------------------------------- if (uniform) : Bmap = np.ones(12*nside**2, dtype) if (Bmap0 is not None) : Bmap *= Bmap0[Bmap0.size/2] return Bmap #-------------------------------------------------- if (Bmap0 is not None) : nside0 = hp.get_nside(Bmap0) if (nside0 != nside) : Bmap0 = hp.ud_grade(nside, Bmap0) Bmap0 = Bmap0.astype(dtype) #-------------------------------------------------- else : n = hp.ang2pix(nside, np.pi/2, 0) Bmap0 = np.zeros(12*nside**2, dtype) Bmap0[n] = 10000 D = Asarray(dwl)[0] fwhm = 1.03 * 300/freq / D Bmap0 = hp.smoothing(Bmap0, fwhm, verbose=False) Bmap0[Bmap0<0] = 0 Bmap0 /= Bmap0.sum() #-------------------------------------------------- if (pointRA is None) : pointRA = 0 if (pointDec is None) : pointDec = 0 if (abs(pointRA)<1e-4 and abs(pointDec)<1e-4) : return Bmap0 #-------------------------------------------------- theta, phi = hp.pix2ang(nside, np.arange(12*nside**2)) theta, phi = CoordTrans.thetaphiRotation([theta, phi], az=pointRA, ay=-pointDec) n = hp.ang2pix(nside, theta, phi) Bmap = Bmap0[n] return Bmap
def idea_jon():
nside_spin = 512
ra0 = 0
dec0 = -90
az_throw = 10
max_spin = 5
fwhm = 32.2
scan_opts = dict(verbose=1,
ra0=ra0,
dec0=dec0,
az_throw=az_throw,
nside_spin=nside_spin,
max_spin=max_spin,
binning=True)
lmax = 800
alm = tools.gauss_blm(1e-5, lmax, pol=False)
ell = np.arange(lmax + 1)
fl = np.sqrt((2 * ell + 1) / 4. / np.pi)
hp.almxfl(alm, fl, mmax=None, inplace=True)
fm = (-1)**(hp.Alm.getlm(lmax)[1])
alm *= fm
alm = tools.get_copol_blm(alm)
# create Beam properties and pickle (this is just to test load_focal_plane)
import tempfile
import shutil
import pickle
opj = os.path.join
blm_dir = os.path.abspath(
opj(os.path.dirname(__file__), '../tests/test_data/example_blms'))
po_file = opj(blm_dir, 'blm_hp_X1T1R1C8A_800_800.npy')
eg_file = opj(blm_dir, 'blm_hp_eg_X1T1R1C8A_800_800.npy')
tmp_dir = tempfile.mkdtemp()
beam_file = opj(tmp_dir, 'beam_opts.pkl')
beam_opts = dict(az=0,
el=0,
polang=0.,
btype='Gaussian',
name='X1T1R1C8',
fwhm=fwhm,
lmax=800,
mmax=800,
amplitude=1.,
po_file=po_file,
eg_file=eg_file)
with open(beam_file, 'wb') as handle:
pickle.dump(beam_opts, handle, protocol=pickle.HIGHEST_PROTOCOL)
# init scan strategy and instrument
ss = ScanStrategy(
1., # mission duration in sec.
sample_rate=10000,
location='spole')
ss.allocate_maps(nside=1024)
ss.load_focal_plane(tmp_dir, no_pairs=True)
# remove tmp dir and contents
shutil.rmtree(tmp_dir)
ss.set_el_steps(0.01, steps=np.linspace(-10, 10, 100))
# Generate maps with Gaussian beams
ss.scan_instrument_mpi(alm, **scan_opts)
ss.reset_el_steps()
# Solve for the maps
maps_g, cond_g = ss.solve_for_map(fill=np.nan)
# Generate maps with elliptical Gaussian beams
ss.allocate_maps(nside=1024)
ss.beams[0][0].btype = 'EG'
ss.scan_instrument_mpi(alm, **scan_opts)
ss.reset_el_steps()
# Solve for the maps
maps_eg, cond_eg = ss.solve_for_map(fill=np.nan)
# Generate map with Physical Optics beams and plot them
ss.allocate_maps(nside=1024)
ss.beams[0][0].btype = 'PO'
ss.scan_instrument_mpi(alm, **scan_opts)
ss.reset_el_steps()
# Solve for the maps
maps_po, cond_po = ss.solve_for_map(fill=np.nan)
# Plotting
print('plotting results')
cart_opts = dict( #rot=[ra0, dec0, 0],
lonra=[-min(0.5 * az_throw, 10),
min(0.5 * az_throw, 10)],
latra=[-min(0.375 * az_throw, 10),
min(0.375 * az_throw, 10)],
unit=r'[$\mu K_{\mathrm{CMB}}$]')
# plot smoothed input maps
nside = hp.get_nside(maps_g[0])
hp.smoothalm(alm, fwhm=np.radians(fwhm / 60.), verbose=False)
maps_raw = hp.alm2map(alm, nside, verbose=False)
plot_iqu(maps_raw,
'../scratch/img/',
'raw_delta',
sym_limits=[1, 1, 1],
plot_func=hp.cartview,
**cart_opts)
def trygveplot(input,
dataset=None,
nside=None,
auto=False,
min=False,
max=False,
mid=[],
rng="auto",
colorbar=False,
graticule=False,
lmax=None,
fwhm=0.0,
mask=None,
mfill=None,
sig=[
0,
],
remove_dipole=None,
remove_monopole=None,
logscale=False,
size="m",
white_background=False,
darkmode=False,
png=False,
cmap=None,
title=None,
ltitle=None,
unit=None,
scale=None,
outdir='.',
outname=None,
verbose=False,
fontsize=11,
gif=False,
oldfont=False,
dpi=300,
xsize=2000,
hires=False):
"""
Plots a fits file, a h5 data structure or a data array in Mollview with pretty formatting.
Option of autodecting component base on file-string with json look-up table.
Parameters
----------
input : array, str or list
String or list of strings with filenames such as "cmb.fits" or "chain_c001.h5" for input data.
dataset : str
if input is a .h5 hdf-file specify which dataset to plot, for example "000007/cmb/amp_alm"
default = None
nside : int
nside for optional ud_grade (required when loading from hdf file)
default = None
auto : bool
Toggle parameter autodetector.
Automatic identification of plotting parameters based on information from autoparams.json
default = False
min : str
Minimum value of colorbar. Overrides autodetector.
default = False
max : str
Maximum value of colorbar. Overrides autodetector.
default = False
mid : list
Adds tick values between min and max. Accepts multiple ex. -mid 2 -mid 3.
default = []
range : str
Min and max value around 0 (ex. 10).
Also compatible with "auto": sets to 97.5 percentile of data.
Also compatible with "minmax": sets to min and max values.
default = "auto"
colorbar : bool
Adds a colorbar, and "cb" to output filename.
default = False
graticule : bool
Adds graticule to figure.
default = False
lmax : float
Set the lmax of alm input data from hdf.
If reading hdf and not set, this is automatically found.
default = None
fwhm : float
Optional map smoothing. FWHM of gaussian smoothing in arcmin.
default = 0.0
mask : str
Apply a mask file (supply filename) to data (uses signal 0).
default = None
mfill : str
Color to fill masked area, for example "gray".
Transparent by default.
defualt : None
sig : list of int
Signal indices to be plotted. 0, 1, 2 interprated as IQU.
Supports multiple, such that -sig 1 -sig 2.
default = [0,]
remove_dipole : str
Fits and removes a dipole. Specify mask for fit, or "auto".
default = None
remove_monopole : str
Fits and removes a monopole. Specify mask for fit, or "auto".
default = None
logscale : str
Normalizes data using a semi-logscale linear between -1 and 1.
Autodetector uses this sometimes, you will be warned.
default = None
size : str
Size of output maps.
1/3, 1/2 and full page width (8.8/12/18cm) [ex. x, s, m or l, or ex. slm for all]"
default = "m"
white_background : bool
Sets white background. Transparent by default.
default = False
darkmode : bool
Plots all outlines in white for dark backgrounds, and adds "dark" in filename.
default = False
png : bool
Saves file as png as opposed to PDF. Overwritten by outname extension.
default = False
cmap : str
Colormap (ex. sunburst, planck, jet). Both matplotliib and cmasher available as of now.
Also supports qualitative plotly map, [ex. q-Plotly-4 (q for qualitative 4 for max color)]
Sets planck as default.
default = None
title : str
Sets the upper right title. Has LaTeX functionaliity (ex. $A_{s}$.)
default = None
ltitle : str
Sets the upper left title. Has LaTeX functionaliity (ex. $A_{s}$.)
default = None
unit : str
Sets uniit under color bar. Has LaTeX functionaliity (ex. $\mu K$".
default = None
scale : float
Scale data by multiplicatiive factor. [ex. 1e-6 for muK to K
default = None
outdir : path
Optiional different output directory.
default = "."
outname : str
Output filename. If not specified, descriptive filename will be generated from chosen params.
Extension determines filetype and overrides -png flag.
default = None
gif : bool
Make gif is input is list of data.
defaullt = False
oldfont : bool
Use DejaVu font as oppoosed to Times.
default = False
fontsize : int
Fontsize
default = 11
dpi : int
DPI (Dots per inch). For figure resolution.
default = 300
xsize : int
Figure width in pixels. Uses xsize*(xsize/2)
default = 2000
hires : bool
For high resolution figures. Sets dpi to 3000 and xsize to 10000.
default = False
verbose : bool
Verbose mode. Mainly timer outputs.
default = False
"""
if hires:
xsize = 10000
dpi = 1000
if not oldfont:
plt.rcParams["mathtext.fontset"] = "stix"
plt.rcParams["backend"] = "agg" if png else "pdf"
if outname:
plt.rcParams["backend"] = "agg" if outname.endswith("png") else "pdf"
plt.rcParams["axes.linewidth"] = 1
if darkmode:
params = [
"text.color", "axes.facecolor", "axes.edgecolor",
"axes.labelcolor", "xtick.color", "ytick.color", "grid.color",
"legend.facecolor", "legend.edgecolor"
]
for p in params:
plt.rcParams[p] = "white"
### Terminal output for
click.echo("")
click.echo(click.style("{:#^48}".format(""), fg="green"))
click.echo(
click.style("Plotting", fg="green") + f" {input} dset={dataset}")
#### READ MAP #####
maps_, lmax, outfile, signal_labels = get_map(
input,
sig,
dataset,
nside,
lmax,
fwhm,
)
# Terminal output specified signals
click.echo(click.style("Using signals ", fg="green") + f"{sig}")
click.echo(click.style("{:#^48}".format(""), fg="green"))
#### Main plotting loop ####
imgs = [] # Store images for gif
for i, maps in enumerate(maps_):
if maps.ndim == 1: maps = maps.reshape(1, -1)
for pl, polt, in enumerate(sig):
#### Select data column #####
m = hp.ma(maps[pl])
signal_label = signal_labels[
polt] if signal_labels else get_signallabel(polt)
nsid = hp.get_nside(m)
#### Smooth #####
if float(fwhm) > 0 and input[i].endswith(".fits"):
click.echo(
click.style(f"Smoothing fits map to {fwhm} arcmin fwhm",
fg="yellow"))
m = hp.smoothing(
m,
fwhm=arcmin2rad(fwhm),
lmax=lmax,
)
#### ud_grade #####
if nside is not None and input[i].endswith(".fits"):
if nsid != nside:
click.echo(
click.style(f"UDgrading map from {nsid} to {nside}",
fg="yellow"))
m = hp.ud_grade(
m,
nside,
)
else:
nside = nsid
#### Remove monopole or dipole #####
if remove_dipole or remove_monopole:
m = remove_md(m, remove_dipole, remove_monopole, nside)
#### Scaling factor #####
if scale:
datastring = f"{outfile}{outname}"
if "chisq" in datastring:
click.echo(
click.style(f"Scaling chisq data with dof={scale}",
fg="yellow"))
m = (m - scale) / np.sqrt(2 * scale)
else:
click.echo(
click.style(f"Scaling data by {scale}", fg="yellow"))
m *= scale
#### Automatic variables #####
if auto:
(
m,
ttl,
lttl,
unt,
ticks,
cmp,
lgscale,
) = get_params(
m,
outfile,
outname,
signal_label,
)
# Tick bug fix
mn, md, mx = (ticks[0], None, ticks[-1])
if not mid and len(ticks) > 2:
if ticks[0] < ticks[1] and ticks[-2] < ticks[-1]:
md = ticks[1:-1]
else:
ticks.pop(1)
else:
ttl = lttl = unt = ""
mn = md = mx = None
ticks = [False, False]
lgscale = False
cmp = "planck"
#if "diff" in outname+outfile:
# click.echo(click.style("Changing cmap to planck because diff map!", fg="yellow", blink=True, bold=True))
# cmp = "planck"
#### Commandline priority ####
if logscale != None: lgscale = logscale
if title: ttl = title
if ltitle: lttl = ltitle
if unit: unt = unit
#### Colorbar ticks ####
ticks = get_ticks(m, ticks, mn, md, mx, min, mid, max, rng, auto)
ticklabels = [fmt(i, 1) for i in ticks]
# Terminal ouput
click.echo(click.style("FWHM: ", fg="green") + f"{fwhm}")
click.echo(click.style("nside: ", fg="green") + f"{nside}")
click.echo(click.style("Ticks: ", fg="green") + f"{ticks}")
click.echo(click.style("Unit: ", fg="green") + f"{unt}")
click.echo(click.style("Title: ", fg="green") + f"{ttl}")
#### Logscale ####
if lgscale: m, ticks = apply_logscale(m, ticks, linthresh=1)
#### Color map #####
cmap_ = get_cmap(cmap, cmp, logscale=lgscale)
#### Projection ####
grid_pix, longitude, latitude = project_map(
nside,
xsize=xsize,
ysize=int(xsize / 2.0),
)
#### Mask ##########
grid_map, cmap_ = apply_mask(m, mask, grid_pix, mfill, polt,
cmap_) if mask else (m[grid_pix],
cmap_)
for width in get_sizes(size):
click.echo(click.style("Size: ", fg="green") + str(width))
#### Make figure ####
height = width / 2.0
if colorbar:
height *= 1.275 # Make sure text doesnt change with colorbar
if gif:
# Hacky gif implementation
if i == 0:
fig = plt.figure(figsize=(
cm2inch(width),
cm2inch(height),
), )
ax = fig.add_subplot(111, projection="mollweide")
else:
fig = plt.figure(figsize=(
cm2inch(width),
cm2inch(height),
), )
ax = fig.add_subplot(111, projection="mollweide")
#norm=col.SymLogNorm(linthresh=1, base=10) if logscale else None
image = plt.pcolormesh(longitude[::-1],
latitude,
grid_map,
vmin=ticks[0],
vmax=ticks[-1],
rasterized=True,
cmap=cmap_,
shading='auto',
animated=gif)
# Save img for gif
if gif: imgs.append([image])
#### Graticule ####
if graticule: apply_graticule(ax, width)
ax.xaxis.set_ticklabels([])
ax.yaxis.set_ticklabels([]) # rm lonlat ticklabs
#### Colorbar ####
if colorbar:
apply_colorbar(fig,
image,
ticks,
ticklabels,
unt,
fontsize,
linthresh=1,
logscale=lgscale)
#### Right Title ####
plt.text(
4.5,
1.1,
r"%s" % ttl,
ha="center",
va="center",
fontsize=fontsize,
)
#### Left Title ####
plt.text(
-4.5,
1.1,
r"%s" % lttl,
ha="center",
va="center",
fontsize=fontsize,
)
#### Output file ####
plt.tight_layout()
if gif: #output gif on last iteration only
if i == len(input) - 1:
output_map(fig, outfile, png, fwhm, colorbar, mask,
remove_dipole, darkmode, white_background,
cmap_, nside, signal_label, width, outdir,
gif, imgs, dpi, verbose, outname)
else:
output_map(fig, outfile, png, fwhm, colorbar, mask,
remove_dipole, darkmode, white_background,
cmap_, nside, signal_label, width, outdir, gif,
imgs, dpi, verbose, outname)
click.echo("Saved, closing fig")
plt.close()
click.echo(
"Totaltime:",
(time.time() - totaltime),
) if verbose else None
#####################################################################
print "Reading healpix maps"
sehgalTMap = hp.read_map("./input/sehgal_maps/" + nuStr.zfill(3) +
"_rad_pts_healpix.fits")
#pathOut = "/global/cscratch1/sd/eschaan/SehgalRadioPolarizedSources/output/sehgal_maps/radio_sources/"
pathOut = "./output/sehgal_maps/radio_sources/"
tMap = hp.read_map(pathOut + "t_radio_sehgal_" + nuStr +
"ghz_muk_scatter.fits")
qMap = hp.read_map(pathOut + "q_radio_sehgal_" + nuStr +
"ghz_muk_scatter.fits")
uMap = hp.read_map(pathOut + "u_radio_sehgal_" + nuStr +
"ghz_muk_scatter.fits")
nSide = hp.get_nside(tMap)
cmb = CMB(beam=beamFwhm,
noise=noiseT,
nu1=nu,
nu2=nu,
lMin=30.,
lMaxT=3.e3,
lMaxP=5.e3,
fg=True,
atm=True,
atmProp=[lKnee, aKnee, lKnee, aKnee],
name=None)
####################################################################
# ## Read the kappa map
def __init__(self,
inputwhat=None,
which=(1, 0),
ordering=None,
coordsys=None,
unit=None,
nside=None,
freq=None,
dtype=None,
Nprocess=None,
verbose=False):
'''
Input map must be healpix map
inputwhat, which:
(1) Path of healpix map with ".fits":
which = (hdu, field)
(2) Path of healpix map with ".hdf5":
hpmap = h5py.open(inputwhat)[which]
which is the key (str)
(3) np.ndarray with healpix pixelization (size=12*2**n)
which is invalid here
ordering:
'RING' | 'NESTED'
the output ordering of self.hpmap
coordsys:
'Equatorial' | 'Galactic'
the output coordsys of self.hpmap
unit:
'K' | 'mK' | 'uK'
the output unit of self.hpmap
nside:
the output nside of self.hpmap
dtype:
'float32' | 'float64' | np.float32 | np.float64
the output self.hpmap.dtype
'''
import os, pyfits
import healpy as hp
import numpy as np
from jizhipy.Process import NprocessCPU
from jizhipy.Basic import IsType
self.verbose = bool(verbose)
if (self.verbose): print('HealpixMap.__init__:')
self.Nprocess = NprocessCPU(Nprocess)[0]
self.ordering, self.nest = self._OrderingCheck(None, ordering)[2:]
self.coordsys = self._CoordsysCheck(None, coordsys)[1]
self.nside = self._NsideCheck(nside)
self.unit = self._UnitCheck(None, unit)[1]
if (dtype is not None):
try:
dtype = np.dtype(dtype)
except:
dtype = None
self.dtype = dtype
self.freq = freq
if (self.verbose):
try:
freqstr = ('%.1fMHz' % self.freq)
except:
freqstr = str(self.freq)
print(" ordering=" + str(self.ordering) + "(nest=" +
str(self.nest) + "), coordsys=" + str(self.coordsys) +
", nside=" + str(self.nside) + ", unit=" + str(self.unit) +
", dtype=" + str(self.dtype) + ', freq=' + freqstr)
#--------------------------------------------------
if (not IsType.isstr(inputwhat)):
self.hpmap = np.array(inputwhat)
self.nsidein = hp.get_nside(self.hpmap)
self.dtypein = self.hpmap.dtype
self.hpmap = np.array(self.hpmap, self.dtype)
self.dtype = self.hpmap.dtype
self.inputwhat = None
self.orderingin = None
self.coordsysin = None
self.unitin = None
self.freqin = None
printstrNone = ['orderingin', 'coordsysin', 'unitin', 'freqin']
if (self.verbose):
print(' inputwhat is np.ndarray')
print(
' orderingin = coordsysin = unitin = freqin = None. You can use HealpixMap.InProperty() to set them'
)
#--------------------------------------------------
elif ('.fits' == str(inputwhat).lower()[-5:]):
printstrNone = []
self.inputwhat = os.path.abspath(os.path.expanduser(inputwhat))
fo = pyfits.open(self.inputwhat)
hdr = fo[0].header
for i in range(1, which[0] + 1):
hdr.update(fo[i].header)
fo = fo[which[0]]
self.dtypein = np.dtype(fo.data.dtype[which[1]].name)
self.hpmap = np.array(fo.data[fo.data.names[which[1]]],
self.dtype) # Read data directly
self.dtype = self.hpmap.dtype
self.nsidein = hp.get_nside(self.hpmap)
#--------------------------------------------------
try:
orderingin = str(hdr['ORDERING']).upper()
orderingin, nestin = self._OrderingCheck(orderingin)[:2]
except:
printstrNone.append('orderingin')
orderingin, nestin = None, None
self.orderingin, self.nestin = orderingin, nestin
#--------------------------------------------------
try:
try:
coordsysin = str(hdr['COORDSYS']).lower()
except:
coordsysin = str(hdr['SKYCOORD']).lower()
coordsysin = self._CoordsysCheck(coordsysin)[0]
except:
printstrNone.append('coordsysin')
coordsysin = None
self.coordsysin = coordsysin
#--------------------------------------------------
unitin = 'None'
try:
unitin = str(hdr['TUNIT' + str(which[1] + 1)])
unitin = self._UnitCheck(unitin)[0]
except:
if (self.verbose):
print(" Warning: unitin = " + unitin +
" not in ['K', 'mK', 'uK']")
printstrNone.append('unitin')
unitin = None
self.unitin = unitin
#--------------------------------------------------
printstr = ''
try:
n = hdr.keys().index('FREQ')
freqin, com = str(hdr['FREQ']).lower(), hdr.comments[n].lower()
if ('ghz' in freqin or 'ghz' in com):
freqin = 1e3 * float(freqin.split('ghz')[0])
elif ('mhz' in freqin or 'mhz' in com):
freqin = float(freqin.split('mhz')[0])
elif ('hz' in freqin or 'hz' in com):
freqin = float(freqin.split('hz')[0])
else:
printstr = 'FREQ : ' + freqin + ' / ' + com + ", NOT with unit ['Hz', 'MHz', 'GHz']"
except:
printstrNone.append('freqin')
freqin = None
self.freqin = freqin
if (self.verbose):
try:
freqstrin = ('%.1fMHz' % self.freqin)
except:
freqstrin = str(self.freqin)
print(' inputwhat="' + inputwhat + '"')
print(" orderingin=" + str(self.orderingin) + "(nestin=" +
str(self.nestin) + "), coordsysin=" +
str(self.coordsysin) + ", nsidein=" + str(self.nsidein) +
", unitin=" + str(self.unitin) + ", dtypein=" +
str(self.dtypein) + ', freqin=' + freqstrin)
#--------------------------------------------------
# Do
if (self.orderingin is not None):
# coordsys
if (self.coordsysin is None and self.coordsys is not None):
if (self.verbose):
print(" Warning: coordsysin = None, coordsys = '" +
self.coordsys + "', can NOT change")
self.coordsys = None
elif (self.coordsysin is None and self.coordsys is None):
pass
elif (self.coordsysin is not None and self.coordsys is None):
self.coordsys = self.coordsysin
elif (self.coordsysin != self.coordsys):
self.CoordsysConvert()
#--------------------------------------------------
# ordering
if (self.ordering is None):
self.ordering, self.nest = self.orderingin, self.nestin
if (self.orderingin != self.ordering): self.OrderingConvert()
#--------------------------------------------------
# nside
if (self.nside is None): self.nside = self.nsidein
if (self.nsidein != self.nside):
self.NsideConvert(None, self.ordering)
#--------------------------------------------------
try:
self.unit + self.unitin
self.UnitConvert()
except:
pass
try:
self.freq + self.freqin
self.FreqConvert()
except:
pass
def get_map(
input,
sig,
dataset,
nside,
lmax,
fwhm,
):
# Get maps array if .h5 file
signal_labels = None
maps = []
input = [input] if isinstance(input, (str, np.ndarray)) else input
if not input:
print("No input specified")
sys.exit()
for input_ in input:
if isinstance(input_, np.ndarray):
if not nside: nside = hp.get_nside(input_)
if not lmax: lmax = 2.5 * nside
outfile = "figure"
if input_.ndim > 1:
maps_ = input_[sig]
else:
maps_ = input_
elif input_.endswith(".h5"):
from src.commands_hdf import h5map2fits
from src.tools import alm2fits_tool
# Get maps from alm data in .h5
if dataset.endswith("alm"):
if not nside:
click.echo(
click.style("Specify nside for h5 files", fg="red"))
sys.exit()
click.echo(click.style("Converting alms to map", fg="green"))
(
maps_,
_,
_,
_,
outfile,
) = alm2fits_tool(
input_,
dataset,
nside,
lmax,
fwhm,
save=False,
)
maps_ = maps_[sig]
# Get maps from map data in .h5
elif dataset.endswith("map"):
click.echo(click.style("Reading map from hdf", fg="green"))
(
maps_,
_,
_,
outfile,
) = h5map2fits(input_, dataset, save=False)
maps_ = maps_[sig]
# Found no data specified kind in .h5
else:
click.echo(
click.style("Dataset not found. Breaking.", fg="red"))
click.echo(
click.style(f"Does {input_}/{dataset} exist?", fg="red"))
sys.exit()
elif input_.endswith(".fits"):
maps_, header = hp.read_map(
input_,
field=sig,
verbose=False,
h=True,
dtype=None,
)
header = dict(header)
signal_labels = []
for i in range(int(header["TFIELDS"])):
signal_label = header[f"TTYPE{i+1}"]
if signal_label in ["TEMPERATURE", "TEMP"]:
signal_label = "T"
if signal_label in ["Q-POLARISATION", "Q_POLARISATION"]:
signal_label = "Q"
if signal_label in ["U-POLARISATION", "U_POLARISATION"]:
signal_label = "U"
signal_labels.append(signal_label)
outfile = input_.replace(".fits", "")
else:
click.echo(click.style("Did not recognize data.", fg="red"))
sys.exit()
if maps_.ndim == 1: maps_ = maps_.reshape(1, -1)
maps.append(maps_)
return maps, lmax, outfile, signal_labels
