def view_observed_gsm(self, logged=False, show=False, **kwargs):
""" View the GSM (Mollweide), with below-horizon area masked. """
sky = self.observed_sky
if logged:
sky = np.log2(sky)
# Get RA and DEC of zenith
ra_rad, dec_rad = self.radec_of(0, np.pi / 2)
ra_deg = ra_rad / np.pi * 180
dec_deg = dec_rad / np.pi * 180
# Apply rotation
derotate = hp.Rotator(rot=[ra_deg, dec_deg])
g0, g1 = derotate(self._theta, self._phi)
pix0 = hp.ang2pix(self._n_side, g0, g1)
sky = sky[pix0]
coordrotate = hp.Rotator(coord=['C', 'G'], inv=True)
g0, g1 = coordrotate(self._theta, self._phi)
pix0 = hp.ang2pix(self._n_side, g0, g1)
sky = sky[pix0]
hp.mollview(sky, coord='G', **kwargs)
if show:
plt.show()
return sky
def view(self, idx=0, logged=False):
""" View generated map using healpy's mollweide projection.
Parameters
----------
idx: int
index of map to view. Only required if you generated maps at
multiple frequencies.
logged: bool
Take the log of the data before plotting. Defaults to False.
"""
if self.generated_map_data is None:
raise RuntimeError("No GSM map has been generated yet. Run generate() first.")
if self.generated_map_data.ndim == 2:
gmap = self.generated_map_data[idx]
freq = self.generated_map_freqs[idx]
else:
gmap = self.generated_map_data
freq = self.generated_map_freqs
if logged:
gmap = np.log2(gmap)
hp.mollview(gmap, coord='G',
title='Global Sky Model %s %s' % (str(freq), self.unit))
plt.show()
def _interp_beam(self,beam_file,pol,chan):
line0=open(beam_file).readlines()[0]
if 'dBi' in line0:
db=True
else:
db=False
print('db='+str(db))
data=n.loadtxt(beam_file,skiprows=2);
theta,phi=hp.pix2ang(self.nSide,range(self.nPix))
theta=n.round(n.degrees(theta)).astype(int)
phi=n.round(n.degrees(phi)).astype(int)
if db:
self.data[pol,chan,:]=10**((data[:,2].squeeze().reshape(360,181))[phi,theta]/10.)
else:
self.data[pol,chan,:]=(data[:,2].squeeze().reshape(360,181))[phi,theta]
self.data[pol,chan,:]/=self.data[pol,chan,:].flatten().max();
#print('rotatexy='+str(self.rotatexy))
if self.rotatexz:
self.data[pol,chan,:]=rotateBeam(self.data[pol,chan,:].flatten(),rot=[0,-90,0])
if self.rotatexy:
self.data[pol,chan,:]=rotateBeam(self.data[pol,chan,:].flatten(),rot=[-90,0,90])
if(self.invert):
self.data[pol,chan,:]=rotateBeam(self.data[pol,chan,:].flatten(),rot=[0,180,0])
if DEBUG:
hp.mollview(self.data[pol,chan,:])
plt.show()
self.data[pol,chan,theta>90.]=0.
def plot_sky_projection_healpy_count(Sliced_Halo_data,nside):
HEALPix_mode = read_data_bool(tag_name = 'HEALPix_Cartesian',file_name = 'parameters/Output_Parameters.xml')
HEALPix_grat = read_data_bool(tag_name = 'HEALPix_Graticule',file_name = 'parameters/Output_Parameters.xml')
fdir = './Output/plots/HEALPix/'
Sl_n = len(Sliced_Halo_data)
Z_max = max(Sliced_Halo_data[Sl_n-1].Z_red[:])
rc('text',usetex=True)
for k in range(Sl_n):
pix = zeros(12*nside**2)
n = len(Sliced_Halo_data[k].RA[:])
for i in range(n):
j = hp.ang2pix(nside,DtoR*(90.0-Sliced_Halo_data[k].DEC[i]),DtoR*Sliced_Halo_data[k].RA[i])
pix[j] += 1
clf()
if (HEALPix_mode):
hp.cartview(pix)
else:
hp.mollview(pix)
if (HEALPix_grat):
hp.graticule()
fname = 'sky_projection_HEALPix_Count_%i_%i.pdf'%(nside,(k+1))
title(r'sky projection for redshift between %0.2f and %0.2f'%(Sliced_Halo_data[k].z_min,Sliced_Halo_data[k].z_max),fontsize = 20)
print 'Saving plot', fname
savefig(fdir+fname,bbox_inches='tight')
rc('text',usetex=False)
close()
return 0
def plot_map(n, limit, radius='small'):
"""
Plot the sky area there there are fewer than N stars brighter than limit
in a radius of either 'small' (0.7 deg) or 'large' (0.9 deg). For speed, limit
should be one of the mag limits already evaluated
limits = [10.13, 10.02, 9.92, 10.38, 10.29, 10.2, 10.0, 10.1, 10.3]
Makes a mollweide visualization using healpy.
"""
if limit not in limits:
raise ValueError("not calculated for limit {}".format(limit))
if radius == 'small':
if not os.path.exists('small_{}.npy'.format(limit)):
make_maps()
if radius == 'small':
field = np.load('small_{}.npy'.format(limit))
else:
field = np.load('big_{}.npy'.format(limit))
if len(field) != healpy.nside2npix(NSIDE):
make_maps()
if radius == 'small':
field = np.load('small_{}.npy'.format(limit))
else:
field = np.load('big_{}.npy'.format(limit))
map = (field > n).astype('int')
healpy.mollview(map, xsize=2000)
def make_random(nside,data,Nf,outfile=None,viewmap=True,fmt='ascii',rsd=True):
import healpy as hp
import numpy as np
import astropy.table as tab
import matplotlib.pyplot as plt
data_tab = tab.Table.read(data)
ran=np.hstack((data_tab,)*Nf)
Nr=len(ran)
ran['ra']=np.random.uniform(0,360,Nr)
ran['dec']=np.degrees(np.arcsin(np.random.uniform(-1,1,Nr)))
map_gal = make_hp_map(nside,data)
pix_nums = hp.ang2pix(nside,np.pi/2-ran['dec']*np.pi/180,ran['ra']*np.pi/180)
mask = map_gal[pix_nums]>0
if(rsd):
new_random = tab.Table([ran['ra'][mask],ran['dec'][mask],ran['z'][mask]+ran['dz'][mask],np.ones(len(ran['ra'][mask]))],names=('ra','dec','z','w'))
else:
new_random = tab.Table([ran['ra'][mask],ran['dec'][mask],ran['z'][mask],np.ones(len(ran['ra'][mask]))],names=('ra','dec','z','w'))
if(outfile!=None):
new_random.write(outfile,format=fmt)
if(viewmap):
pix_nums = hp.ang2pix(nside,np.pi/2-new_random['dec']*np.pi/180,new_random['ra']*np.pi/180)
bin_count = np.bincount(pix_nums)
map_ran = np.append(bin_count,np.zeros(12*nside**2-len(bin_count)))
plt.figure()
hp.mollview(map_ran)
return ran
def hp_mollweide(map, unit="", title=""):
"""
a wrapper for the healpy mollview functionality
"""
fig = plt.figure()
hp.mollview(map, fig=fig.number, flip="geo", unit=unit, title=title)
return fig, fig.gca()
def main(argv):
_path = '/home/tiago/Develop/SMAPs/'
file15 = 'smpas_obstime_15.fits'
file2 = 'smpas_obstime_2.fits'
extMapFile = 'extintion_at3800.fits'
map15 = H.read_map(os.path.join(_path,file15))
map2 = H.read_map(os.path.join(_path,file2))
extMap = H.read_map(os.path.join(_path,extMapFile))
fig = py.figure(1,figsize=(8,3))
H.mollview(map2*10**(-extMap),fig=1,coord=['G','E'],title='secz < 2.0',sub=(1,2,1),max=1296,cbar=False,notext=True)#,unit='hours z < 1.3')
H.graticule()
H.mollview(map15*10**(-extMap),fig=1,coord=['G','E'],title='secz < 1.5',sub=(1,2,2),max=1296,cbar=False,notext=True)#,unit='hours z < 1.3')
H.graticule()
#H.write_map(os.path.join(_path,'dcorr_'+file15),map15*10**(-extMap))
#H.write_map(os.path.join(_path,'dcorr_'+file2),map2*10**(-extMap))
#H.write_map(os.path.join(_path,'dcorr_'+file3),map3*10**(-extMap))
py.savefig(os.path.join(_path,'Figures/fig2.png'))
py.show()
def plot_tsfile(file,skiprows=32,column=22):
data = np.loadtxt(file,skiprows=skiprows,unpack=True)
print len(data[0])
nside=int(round(mt.sqrt(len(data[9])/12)))
tsarray=np.zeros(nside*nside*12)
index=np.array(data[0]).astype(int)
'''
data2=np.transpose(0*data)
data2[index]=np.transpose(data)
data2=np.transpose(data2)
print(data2[0])
print(data2[10])
return
'''
tsarray[index]=data[column]
tsarray_s = hp.sphtfunc.smoothing(tsarray,sigma = 1.023/nside)
hp.mollview(tsarray,coord=['C','G'], title='TS Map', unit='prob',xsize = 2048)
hp.graticule()
plt.savefig("%s_c%d.png" % (file,column))
plt.show()
hp.mollview(tsarray_s,coord=['C','G'], title='TS Map Smoothed', unit='prob',xsize = 2048)
hp.graticule()
plt.savefig("%s_c%d__s.png" % (file,column))
plt.show()
def surv_sum_diff(surveydict,ss=1,nside=128,freq=70,mask_ps=True,fwhm=10.0):
"""
function to genreate smoothed difference between chosen survey and sum of the other 5 surveys from andreas interactive destriper/binner. uses common masks smooth to 10 degrees
fwhm is in degrees, if zero or negative don't smooth at all, default 10 degrees
"""
sumlist=surveydict.keys()
sumlist.remove(ss)
nsum=len(sumlist)
m=hp.ma(np.array(surveydict[sumlist[0]]))/nsum
totalmask=m.mask
if mask_ps==True:
psmask = np.logical_not(np.floor(hp.ud_grade(hp.read_map(glob('/project/projectdirs/planck/data/mission/DPC_maps/dx8/lfi/DX8_MASKs/' + 'mask_ps_%dGHz_*.fits' % freq)[0]), nside,order_out='NEST')))
totalmask=m.mask | psmask
for ss in sumlist[1:]:
m1=hp.ma(np.array(surveydict[ss]))
m=m+m1/nsum
totalmask=m1.mask | totalmask
m.mask=totalmask
m.mask |= np.isnan(m)
m1=hp.ma(np.array(surveydict[ss]))
totalmask=totalmask | m1.mask
d=(m1-m)/2.
d=hp.ud_grade(d,nside,order_in='NEST',order_out='RING')
if fwhm>0:
dsm=hp.ma(hp.smoothing(d.filled(),fwhm*np.pi/180.))
dsm.mask=m.mask
if fwhm<=0:
dsm=d
hp.mollview(dsm,min=-1e-5,max=1e-5,title='SS'+np.str(ss)+ ' - sum of others')
return dsm
def test_observed_mollview():
""" Generate animated maps of observing coverage over 24 hours """
(latitude, longitude, elevation) = ('37.2', '-118.2', 1222)
ov = GSMObserver()
ov.lon = longitude
ov.lat = latitude
ov.elev = elevation
obs = []
for ii in range(0, 24, 1):
ov.date = datetime(2000, 1, 1, ii, 0)
ov.generate(50)
sky = ov.view_observed_gsm(logged=True, show=False, min=9, max=20)
plt.savefig('generated_sky/galactic-%02d.png' % ii)
plt.close()
hp.mollview(sky, coord=['G', 'E'], min=9, max=20)
plt.savefig('generated_sky/ecliptic-%02d.png' % ii)
plt.close()
hp.mollview(sky, coord=['G', 'C'], min=9, max=20)
plt.savefig('generated_sky/equatorial-%02d.png' % ii)
plt.close()
ov.view(logged=True, show=False, min=9, max=20)
plt.savefig('generated_sky/ortho-%02d.png' % ii)
plt.close()
print ii
os.system('convert -delay 20 generated_sky/ortho-*.png ortho.gif')
os.system('convert -delay 20 generated_sky/galactic-*.png galactic.gif')
os.system('convert -delay 20 generated_sky/ecliptic-*.png ecliptic.gif')
os.system('convert -delay 20 generated_sky/equatorial-*.png equatorial.gif')
def _generatePlot(self, table):
coords, proj = self.__getCoordinatesAndProjection()
fignum = 1
self.Plot.figure(num = fignum, tight_layout = True)
pixels = self.__getPixelsData(table)
#pixels = self.__getMaskedPixels(pixels)
cmap = self.Plot.get_cmap(self.Configuration.getValueOf(ChartHealpixOptions.COLOURMAP, "jet"))
cmap.set_under('w')
healpy.mollview(pixels, fig = fignum, coord = [coords, proj], unit = 'mas', title = "",
min = self.__Min, max = self.__Max, flip = 'astro', cbar = False,
cmap = cmap, norm = self.__getNormalization(), nest = self.__nestedPixels())
healpy.graticule(dpar = 30, dmer = 30, coord = proj, local = None, linestyle = ':',
color = 'white')
healpy.projtext(0, 90, "90", lonlat = True, coord = proj,
verticalalignment = 'bottom', horizontalalignment = 'center',
fontsize = 12)
healpy.projtext(0, 270, "-90", lonlat = True, coord = proj,
verticalalignment = 'top', horizontalalignment = 'center',
linespacing = 2.0, fontsize = 12)
healpy.projtext( 179, 0, "180 ", lonlat = True, coord = proj,
verticalalignment = 'center', horizontalalignment = 'right',
fontsize = 12)
healpy.projtext(-179, 0, " -180", lonlat = True, coord = proj,
verticalalignment = 'center', horizontalalignment = 'left',
fontsize = 12)
def main():
star = StarIsolated(90.0, 0.5, 0.5, 10., nside=64)
Flux0 = star.flux(0.0)
# for tt in np.arange(0,360,80):
# star.makeSpot(0,-45,10.,0.8)
# star.makeSpot(45,+00,10.,0.8)
# star.makeSpot(90.,0,10.,0.8)
# for theta in range(0,360,45):
# star.makeSpot(theta,0,10.,0.8)
# star.makeSpot(00,-90,10.,0.8)
# star.makeSpot(0,+45,10.,0.8)
# star.makeSpot(270,-10.,10.,0.8)
# star.makeSpot(180,-45.,10.,0.8)
# star.makeSpot(tt,65.,10.,0.5)
phases = np.linspace(-0.5, 0.5, 100)
flux = np.zeros(len(phases))
for i in range(len(phases)):
flux[i] = star.flux(phases[i]) / Flux0
H.mollview(star.I, sub=211, rot=(-90, -90))
py.subplot(212)
py.plot(phases, flux, 'o')
py.show()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description="Build and test models based on dim reductions and provided spectra",
)
parser.add_argument(
"--metadata_path", type=str, default=".", metavar="PATH", help="Metadata path to work from, if not " "." ""
)
parser.add_argument(
"--lunar_metadata",
type=str,
default=None,
metavar="LUNAR_METADATA",
required=True,
help="File containing lunar ephemeris metadata.",
)
parser.add_argument("--start_dt", type=ani.valid_date, help="DateTime to plot sky for")
parser.add_argument("--end_dt", type=ani.valid_date, help="DateTime to plot sky for")
parser.add_argument("--ra", type=str)
parser.add_argument("--dec", type=str)
args = parser.parse_args()
m = np.zeros(hp.nside2npix(NSIDE))
lunar_row, solar_row, ss_count, ss_area = ani.get_metadata_for_dt(
args.datetime, args.lunar_metadata, args.solar_metadata, args.sunspot_metadata
)
fig = plt.figure(1, figsize=(10, 7.5))
hp.mollview(m, coord=["C"], title="Mollview image RING", fig=1)
plt.show()
def show_CMB_T_map(self,Tmap=None, max=100, title = "CMB graviational potential fluctuations as seen from inside the LSS", from_perspective_of = "observer", cmap=None):
if Tmap is None:
self.NSIDE = 256
self.Tmap = hp.alm2map(self.alm,self.NSIDE)
else:
self.Tmap = Tmap
if from_perspective_of == "observer":
dpi = 300
figsize_inch = 60, 40
fig = plt.figure(figsize=figsize_inch, dpi=dpi)
# Sky map:
hp.mollview(self.Tmap, rot=(-90,0,0), min=-max, max=max, title=title + ", $\ell_{max}=$%d " % self.truncated_lmax, cmap=cmap, unit="$\mu$K")
plt.savefig(title+".png", dpi=dpi, bbox_inches="tight")
else:
# Interactive "external" view ([like this](http://zonca.github.io/2013/03/interactive-3d-plot-of-sky-map.html)) pass
# beatbox.zoncaview(self.Tmap)
# This did not work, sadly. Maybe we can find a 3D
# spherical surface plot routine using matplotlib? For
# now, just use the healpix vis.
R = (0.0,0.0,0.0) # (lon,lat,psi) to specify center of map and rotation to apply
hp.orthview(self.Tmap,rot=R,flip='geo',half_sky=True,title="CMB graviational potential fluctuations as seen from outside the LSS, $\ell_{max}$=%d" % self.truncated_lmax)
print "Ahem - we can't visualize maps on the surface of the sphere yet, sorry."
return
def main():
star = StarBinary(90.0, 0.5, nside=64, limb_law=-1, limb_coeff=[0.8])
Flux0 = star.flux(0.0)
phases = np.linspace(-0.5, 0.5, 100)
flux1 = np.zeros(len(phases))
for i in range(len(phases)):
flux1[i] = star.flux(phases[i]) / Flux0
# for tt in np.arange(0,360,80):
# star.makeSpot(0,-45,10.,0.8)
# star.makeSpot(45,+00,10.,0.8)
# star.makeSpot(00, -90, 20., 0.)
# for theta in range(0,360,45):
# star.makeSpot(theta,65,10.,0.8)
# star.makeSpot(00,-90,20.,0.)
# star.makeSpot(0,+45,10.,0.8)
# star.makeSpot(270,-10.,10.,0.8)
# star.makeSpot(180,-45.,10.,0.8)
# star.makeSpot(tt,65.,10.,0.5)
flux2 = np.zeros(len(phases))
for i in range(len(phases)):
flux2[i] = star.flux(phases[i]) / Flux0
H.mollview(star.I, sub=211, rot=(-90, 90))
#ff = np.loadtxt('/tmp/cl.dat', unpack=True)
py.subplot(212)
py.plot(phases, flux1, '-')
# py.plot(phases,flux2,'-')
#py.plot(ff[0], ff[1], '.')
py.show()
def _main():
"""
This is the main routine.
"""
data = np.loadtxt("all_ts_data_0.1GeVplus.gz",skiprows=32,unpack=True)
print len(data[0])
nside=int(round(mt.sqrt(len(data[9])/12)))
tsarray=data[0]*0
RA=data[8]
decl=data[9]
# index=DeclRaToIndex(decl,RA,nside)
index=hp.nest2ring(nside,np.array(data[0]).astype(int))
tsarray[index]=data[22]
tsarray = hp.sphtfunc.smoothing(tsarray,sigma = 0.008)
# tsmap=0*tsarray
hp.mollview(np.arcsinh(tsarray)/mt.log(10.0),coord='C', title='TS Map', unit='prob',xsize = 2048)
# hp.graticule()
plt.savefig("ts.png")
plt.show()
def __init__(self,cat,nside,theta_apo) :
""" Initializes Mask object from catalog and resolution parameters
Parameters
----------
cat : fc.Catalog
Catalog containing window information
nside : int
HEALPix resolution index
theta_apo : float
Apodization scale in degrees
"""
if cat.window.typestr=='decbcut':
npix=hp.nside2npix(nside)
ind_aux=np.arange(0,npix)
theta,phi=hp.pix2ang(nside,ind_aux)
self.weights=cat.window(phi*180/np.pi,90-theta*180/np.pi)
elif cat.window.typestr=='base':
self.weights=np.ones(12*nside**2)
else:
self.weights=cat.window.map.copy()
if debug:
hp.mollview(self.weights)
plt.show()
#Figure out which pixels are empty
self.ip_nomask=np.where(self.weights>0)[0]
#Generate sky mask and apply apodization
self.binary=np.zeros_like(self.weights)
self.binary[self.ip_nomask]=1.
if theta_apo>0 :
self.mask_apo=nmt.mask_apodization(self.binary,theta_apo,apotype='C1')
else :
self.mask_apo=self.binary.copy()
#Final weights are a combination of mask + depth fluctuations
self.total=self.mask_apo*self.weights
#Can't generate maps with pixels larger than the mask
if (cat.window.typestr!='decbcut') & (cat.window.typestr!='base'):
if nside<cat.window.nside:
#If mask pixelization is higher, upgrade output maps
self.nside=cat.window.nside
else :
#If mask pixelization is lower, upgrade mask
self.nside=nside
self.total =hp.ud_grade(self.total ,nside_out=nside)
self.binary =hp.ud_grade(self.binary ,nside_out=nside)
self.weights=hp.ud_grade(self.weights,nside_out=nside)
self.ip_nomask=np.where(self.weights>0)[0]
else:
self.nside=nside
self.total =hp.ud_grade(self.total ,nside_out=nside)
self.binary =hp.ud_grade(self.binary ,nside_out=nside)
self.weights=hp.ud_grade(self.weights,nside_out=nside)
self.ip_nomask=np.where(self.weights>0)[0]
#Pixel area
self.pixOmega=4*np.pi/hp.nside2npix(self.nside)
if debug:
hp.mollview(self.weights)
plt.show()
def plot_galaxies_and_density(t, p, M):
"""Plots galaxies and pixels from polar form."""
plt.figure(1, dpi=100)
hp.mollview(M, fig=1, nest=True, title='Density')
plt.figure(2, dpi=100)
hp.mollview(M*0-1, fig=2, nest=True, cbar=False, cmap=cm.binary,
min=-1, max=1, title='Galaxies')
hp.projscatter(t, p, marker='.', facecolor='white', s=0.1, alpha=0.9)
def rebuild(self, N, A_, S_, freq_num=100):
self.s = 0
for i in range(N):
self.s = self.s + S_[:, i] * A_[freq_num, i]
hp.mollview(self.s, title='rebuild_freq_%d' % freq_num)
plt.savefig('N_%d_rebuid_freq_%d.eps' % (N, freq_num))
plt.cla()
return self.s
def rebuild(self, N, A_, S_, freq_num=0):
self.s = 0
for i in np.arange(N):
self.s = self.s + S_[:, i] * A_[freq_num, i]
hp.mollview(self.s,min=self.s.mean()-self.s.std(),max=self.s.mean()+self.s.std(), title='rebuild_freq_%d' % freq_num)
plt.savefig('N_%d_rebuid_freq_%d.eps' % (N, freq_num))
plt.cla()
return self.s
def GetComponent(self, N):
plt.clf()
for i in range(N):
mean=S_[:,i].mean()
std=S_[:,i].std()
hp.mollview(S_[:, i],min=mean-std,max=mean+std,title='component $%d$' % (i + 1))
plt.savefig('N_%d_result%i.eps' % (N, i))
plt.cla()
def main():
"""
This is the main routine.
"""
h_nside=512 # The same value a bayesstar.fits
smoothing=0.01 # Smooth the resulting map to 0.01 radians with a Gaussian
hubbleconstant=72
speedoflight=3E5
filenameCat = 'XSC_Completed.tbl.gz'
RA,DEC,JMAG,HMAG,KMAG = np.loadtxt(filenameCat,skiprows= 50,
usecols = (0,1,3,4,5),
dtype=[('f0',float),
('f1',float),
('f2',float),
('f3',float),
('f4',float)], unpack = True)
MK_Star = -24.0
DIST = np.power(10,(KMAG-MK_Star)/5)*1E-05
REDSHIFT = (DIST*hubbleconstant)/speedoflight
print("Interval of K MAG = ",min(KMAG)," - ",max(KMAG))
print("Interval of distances [Mpc] = ",min(DIST)," - ",max(DIST))
print("Interval of redshift = ",min(REDSHIFT)," - ",max(REDSHIFT))
# Select Galaxies by redshift under the assumption of MK=MK_Star
for rmin in np.arange(4)*0.01:
rmax=rmin+0.01
if rmin == 0:
kmin=0
else:
kmin=5*np.log10(rmin/hubbleconstant*speedoflight*1E5)+MK_Star
kmax=5*np.log10(rmax/hubbleconstant*speedoflight*1E5)+MK_Star
galpixels_Range= np.zeros(hp.nside2npix(h_nside))
include_me = np.logical_and((REDSHIFT > rmin),
np.logical_and((REDSHIFT<rmax),
(KMAG != 0.0)))
ra_Range = RA[include_me]
dec_Range = DEC[include_me]
pix_num_Range = (DeclRaToIndex(dec_Range,ra_Range,h_nside))
galpixels_Range[pix_num_Range]+=1
print("Number of objects with %g < z < %g : %d" % (rmin,rmax,len(ra_Range)))
map = hp.sphtfunc.smoothing(galpixels_Range,sigma = smoothing)
hp.write_map("%g-%g_raw.fits" % (rmin,rmax),galpixels_Range)
hp.write_map("%g-%g.fits" % (rmin,rmax),map)
hp.mollview(map,coord='C',rot = [0,0.3], title='Relative Surface Density of Galaxies: %0.1f < K < %0.1f (%g < z < %g)' % (kmin,kmax,rmin,rmax), unit='prob',xsize = 2048)
hp.graticule()
plt.savefig("%g-%g.png" % (rmin,rmax))
plt.show()
def plot(self, filter, ra=None, dec=None):
"""
Plot zoomed zeropoint shiftmap for chosen filter centered on (ra, dec) given in degrees,
or simply Mollweide all-sky map by default.
"""
if ra is not None and dec is not None:
healpy.gnomview(self.zeropoint_shiftmap.data.field(filter), rot=(ra, dec, 0))
else:
healpy.mollview(self.zeropoint_shiftmap.data.field(filter))
def visualize(self, plotname=None, compare=False):
hp.mollview(self.hmap[:,0])
f = plt.gcf()
ax = plt.gca()
if (plotname is not None) & (not compare):
plt.savefig(plotname)
return f, ax
def plot_maps(maps,titles=None):
"""
Plots a list of healpix maps in mollweide projection
"""
s = int(np.ceil(np.sqrt(float(len(maps)))))
for i,m in enumerate(maps):
if titles is not None: hp.mollview(m,title=titles[i],sub=(s,s,i+1))
else: hp.mollview(m,sub=(s,s,i+1))
plt.show()
def ReadMap(self,filename=''):
self.f=h5py.File(filename)
self.map=self.f['map'].value
self.f.close()
for self.i in range(len(self.map)):
self.fig=plt.figure(filename)
hp.mollview(self.map[self.i][0])
plt.savefig(filename+'_freq_%d.png'%self.i)
plt.cla()
return self.map
def get_component():
plt.clf()
for i in range(N):
# hp.mollview(S_[:, i], title='$%d$' %
# (i + 1), sub=((N / 3 + bool(N % 3)) * 100 + 30 + i + 1))
# plt.savefig('component.eps')
# plt.cla()
hp.mollview(S_[:, i], title='component $%d$' % (i + 1))
plt.savefig('N_%d_result%i.eps' % (N, i))
plt.cla()
def get_simpic(N):
for i in range(N):
hp.mollview(map1[i, pol])
plt.title('$signal-21cm-%i$' % i)
plt.savefig('N_%d_signal_21cm_%i.eps' % (N, i))
plt.cla()
for j in range(N):
hp.mollview(map3[j, pol])
plt.title('$signal-galaxy-%i$' % j)
plt.savefig('N_%d_signal_galaxy_%i.eps' % (N, j))
plt.cla()
def setup_scan():
b.make_dirs_for_run(run_tag)
b_disk.make_dirs_for_run(run_tag_disk_only)
b_poiss.make_dirs_for_run(run_tag_poiss)
b_just_NFW.make_dirs_for_run(run_tag_just_NFW)
b_plus_IPS.make_dirs_for_run(run_tag_plus_iso)
b_iso.make_dirs_for_run(run_tag_iso)
hp.mollview(b.mask_total )
plt.savefig(b.plots_dir_for_run + 'mask_ROI.pdf')
plt.close()
def plot_map(self, min_m=-100, max_m=-100, colbar='yes'):
"""
Plots the map after evaluating, the cells are colored with the mean value inside each
one of them
:param float min_m: Lower limit for coloring the cells, -100 uses min value
:param float max_m: Upper limit for coloring the cells, -100 uses max value
:param str colbar: Include a colorbar ('yes','no')
"""
import matplotlib.pyplot as plt
import matplotlib as mpl
import matplotlib.cm as cm
from matplotlib import collections, transforms
from matplotlib.colors import colorConverter
if self.top == 'sphere': import healpy as H
if self.top == 'grid':
M = numpy.zeros(self.npix) - 20.
for i in range(self.npix):
if i in self.yvals:
M[i] = numpy.mean(self.yvals[i])
M2 = numpy.reshape(M, (self.Ntop, self.Ntop))
plt.figure(figsize=(8, 8), dpi=100)
if min_m == -100: min_m = M2[numpy.where(M2 > -10)].min()
if max_m == -100: max_m = M2.max()
SM2 = plt.imshow(M2,
origin='center',
interpolation='nearest',
cmap=cm.jet,
vmin=min_m,
vmax=max_m)
SM2.cmap.set_under("grey")
if colbar == 'yes': plt.colorbar()
plt.axis('off')
if self.top == 'hex':
nx = self.Ntop
ny = self.Ntop
xL = numpy.arange(0, nx, 1.)
dy = 0.8660254
yL = numpy.arange(0, ny, dy)
ny = len(yL)
nx = len(xL)
npix = nx * ny
bX = numpy.zeros(nx * ny)
bY = numpy.zeros(nx * ny)
kk = 0
for jj in range(ny):
for ii in range(nx):
if jj % 2 == 0: off = 0.
if jj % 2 == 1: off = 0.5
bX[kk] = xL[ii] + off
bY[kk] = yL[jj]
kk += 1
xyo = list(zip(bX, bY))
sizes_2 = numpy.zeros(nx * ny) + (
(8. * 0.78 /
(self.Ntop + 0.5)) / 2. * 72.)**2 * 4. * numpy.pi / 3.
M = numpy.zeros(npix) - 20.
fcolors = [
plt.cm.Spectral_r(x) for x in numpy.random.rand(nx * ny)
]
for i in range(npix):
if i in self.yvals:
M[i] = numpy.mean(self.yvals[i])
if max_m == -100: max_m = M.max()
if min_m == -100: min_m = M[numpy.where(M > -10)].min()
M = M - min_m
M = M / (max_m - min_m)
for i in range(npix):
if M[i] <= 0:
fcolors[i] = plt.cm.Greys(.5)
else:
fcolors[i] = plt.cm.jet(M[i])
figy = ((8. * 0.78 / (self.Ntop + 0.5) / 2.) *
(3. * ny + 1) / numpy.sqrt(3)) / 0.78
fig3 = plt.figure(figsize=(8, figy), dpi=100)
#fig3.subplots_adjust(left=0,right=1.,top=1.,bottom=0.)
a = fig3.add_subplot(1, 1, 1)
col = collections.RegularPolyCollection(6,
sizes=sizes_2,
offsets=xyo,
transOffset=a.transData)
col.set_color(fcolors)
a.add_collection(col, autolim=True)
a.set_xlim(-0.5, nx)
a.set_ylim(-1, nx + 0.5)
plt.axis('off')
if colbar == 'yes':
figbar = plt.figure(figsize=(8, 1.), dpi=100)
ax1 = figbar.add_axes([0.05, 0.8, 0.9, 0.15])
cmap = cm.jet
norm = mpl.colors.Normalize(vmin=min_m, vmax=max_m)
cb1 = mpl.colorbar.ColorbarBase(ax1,
cmap=cmap,
norm=norm,
orientation='horizontal')
cb1.set_label('')
if self.top == 'sphere':
M = numpy.zeros(self.npix) + H.UNSEEN
for i in range(self.npix):
if i in self.yvals:
M[i] = numpy.mean(self.yvals[i])
plt.figure(10, figsize=(8, 8), dpi=100)
if min_m == -100: min_m = M[numpy.where(M > -10)].min()
if max_m == -100: max_m = M.max()
if colbar == 'yes':
H.mollview(M,
fig=10,
title="",
min=min_m,
max=max_m,
cbar=True)
if colbar == 'no':
H.mollview(M,
fig=10,
title="",
min=min_m,
max=max_m,
cbar=False)
plt.show()
#hide pixels in the northern hemisphere and plot
print "Plotting..."
#hide pixels that are more than 65 deg from pole or are too close to pole
for i in range(NPIX):
if thetas[i] < 2:
dp[i] = hp.UNSEEN
#mask weirdness at pole
if args.mask and (np.pi - thetas[i]) * 180 / np.pi < args.mask:
dp[i] = hp.UNSEEN
#show in IC standard rotated half sky mollview
if args.moll:
hp.mollview(dp, min=args.min, max=args.max, cbar=False, rot=180)
plt.ylim(-1, .005)
#show an individual pixel's histogram compared to average if specified
#error bars not currently working
elif args.pixel:
#get data, fix errors
data = matrix[args.pixel]
for i in range(len(data)):
if data[i] <= 0:
data[i] = .0001
#normalize, get error bars (not working yet)
sum = float(np.sum(data))
if (i == ydays-1):
h.write_map(dir_out+'/fits/nhits_'+str(i+1)+'_tmp.fits',nhits)
h.write_map(dir_out+'/fits/cos_r1_'+str(i+1)+'_tmp.fits',cos_r1)
h.write_map(dir_out+'/fits/sin_r1_'+str(i+1)+'_tmp.fits',sin_r1)
h.write_map(dir_out+'/fits/cos_r2_'+str(i+1)+'_tmp.fits',cos_r2)
h.write_map(dir_out+'/fits/sin_r2_'+str(i+1)+'_tmp.fits',sin_r2)
h.write_map(dir_out+'/fits/cos_r4_'+str(i+1)+'_tmp.fits',cos_r4)
h.write_map(dir_out+'/fits/sin_r4_'+str(i+1)+'_tmp.fits',sin_r4)
r1 = np.sqrt((cos_r1/np.float_(nhits))**2. + (sin_r1/np.float_(nhits))**2.)
r2 = np.sqrt((cos_r2/np.float_(nhits))**2. + (sin_r2/np.float_(nhits))**2.)
r4 = np.sqrt((cos_r4/np.float_(nhits))**2. + (sin_r4/np.float_(nhits))**2.)
filename_out = dir_out+'/ps/'+filename+'_nhits'
h.write_map(filename_out+'.fits', nhits)
h.mollview(nhits, title='Nobs, '+filename_out, rot=[0.,0.])
h.graticule(dpar=10,dmer=10,coord='E')
py.savefig(filename_out+'.ps')
filename_out = dir_out+'/ps/'+filename+'_cos_r1'
h.write_map(filename_out+'.fits', cos_r1)
h.mollview(cos_r1, title='cos_r1, '+filename_out, rot=[0.,0.])
h.graticule(dpar=10,dmer=10,coord='E')
py.savefig(filename_out+'.ps')
filename_out = dir_out+'/ps/'+filename+'_sin_r1'
h.write_map(filename_out+'.fits', sin_r1)
h.mollview(sin_r1, title='sin_r1, '+filename_out, rot=[0.,0.])
h.graticule(dpar=10,dmer=10,coord='E')
py.savefig(filename_out+'.ps')
64) #reduce nside to make it faster
prob64 = prob64 / np.sum(prob64)
pixels = np.arange(prob64.size)
#sample_points = np.array(hp.pix2ang(nside,pixels)).T
levels = [0.50, 0.90]
theta_contour, phi_contour = compute_contours(levels, prob64)
# Access DESI contours.
#desi_mask = hp.read_map('desi_mask_nside{:04d}.fits'.format(nside_all))
#sum_map[desi_mask == 0] = hp.UNSEEN
# Plot GW skymap in Mollweide projection
hp.mollview(binned_maps[:, k],
cbar=True,
unit=r'probability',
min=0,
max=3e-4,
rot=180,
cmap=cmap)
hp.graticule(ls=':', alpha=0.5, dpar=30, dmer=45) # Set grid lines
# Draw containment contour around GW skymap
nregion = len(theta_contour) // len(levels)
for i, (tc, pc) in enumerate(zip(theta_contour, phi_contour)):
hp.projplot(tc, pc, linewidth=1, c='k')
ax = plt.gca()
# Label latitude lines.
ax.text(2.00, 0.10, r'$0^\circ$', horizontalalignment='left')
ax.text(1.80, 0.45, r'$30^\circ$', horizontalalignment='left')
ax.text(1.30, 0.80, r'$60^\circ$', horizontalalignment='left')
def mkCross(**kwargs):
"""
"""
get_var_from_file(kwargs['config'])
logger.info('Calculating PSF with gtpsf...')
dict_gtpsf = data.DICT_GTPSF
logger.info('Calculating Wbeam Function...')
out_wb_label = data.OUT_W_LABEL
out_wb_txt = os.path.join(GRATOOLS_OUT, 'Wbeam_%s.txt'%out_wb_label)
if not os.path.exists(out_wb_txt):
from GRATools.utils.ScienceTools_ import gtpsf
gtpsf(dict_gtpsf)
from GRATools.utils.gWindowFunc import get_psf
psf_file = data.PSF_FILE
psf = get_psf(psf_file)
_l = np.arange(0, 1000)
from GRATools.utils.gWindowFunc import build_wbeam
wb = build_wbeam(psf, _l, out_wb_txt)
else:
from GRATools.utils.gWindowFunc import get_wbeam
wb = get_wbeam(out_wb_txt)
save_current_figure('Wbeam_%s.png'%out_wb_label, clear=True)
logger.info('Starting Cl analysis...')
in_label1 = data.IN_LABEL1
in_label2 = data.IN_LABEL2
out_label = data.OUT_LABEL
binning_label = data.BINNING_LABEL
mask_file = data.MASK_FILE
mask = hp.read_map(mask_file)
cl_param_file1 = os.path.join(GRATOOLS_OUT, '%s_%s_parameters.txt' \
%(in_label1, binning_label))
cl_param_file2 = os.path.join(GRATOOLS_OUT, '%s_%s_parameters.txt' \
%(in_label2, binning_label))
from GRATools.utils.gFTools import get_cl_param
_emin, _emax, _emean, _f, _ferr, _cn, _fsky = get_cl_param(cl_param_file1)
_emin2, _emax2, _emean2, _f2, _ferr2, _cn2, _fsky2 = get_cl_param(cl_param_file2)
cross_txt = open(os.path.join(GRATOOLS_OUT, '%s_%s_cross.txt' \
%(out_label, binning_label)), 'w')
for i, (emin, emax) in enumerate(zip(_emin, _emax)):
logger.info('Considering bin %.2f - %.2f ...'%(emin, emax))
gamma = data.WEIGHT_SPEC_INDEX
Im = (1/(1-gamma))*(emax**(1-gamma)-emin**(1-gamma))/(emax-emin)
eweightedmean = np.power(1/Im, 1/gamma)
cross_txt.write('ENERGY\t %.2f %.2f %.2f\n'%(emin, emax, eweightedmean))
l_max= 1000
_l = np.arange(l_max)
wb_en = wb.hslice(eweightedmean)(_l)
flux_map_name1 = in_label1+'_flux_%i-%i.fits'%(emin, emax)
flux_map_name2 = in_label2+'_flux_%i-%i.fits'%(emin, emax)
flux_map1 = hp.read_map(os.path.join(GRATOOLS_OUT_FLUX, flux_map_name1))
flux_map2 = hp.read_map(os.path.join(GRATOOLS_OUT_FLUX, flux_map_name2))
flux_map_masked1 = hp.ma(flux_map1)
flux_map_masked1.mask = np.logical_not(mask)
flux_map_masked2 = hp.ma(flux_map2)
flux_map_masked2.mask = np.logical_not(mask)
fsky1 = 1.-(len(np.where(flux_map_masked1.filled() == hp.UNSEEN)[0])/\
float(len(flux_map1)))
fsky2 = 1.-(len(np.where(flux_map_masked2.filled() == hp.UNSEEN)[0])/\
float(len(flux_map2)))
if kwargs['show'] == True:
hp.mollview(flux_map_masked1.filled(), title='f$_{sky}$ = %.3f'%fsky,
min=1e-7, max=1e-4, norm='log')
plt.show()
print 'fsky = ', fsky1, fsky2
fsky = np.sqrt(fsky1*fsky2)
nside1 = hp.npix2nside(len(flux_map1))
nside2 = hp.npix2nside(len(flux_map1))
wpix1 = hp.sphtfunc.pixwin(nside1)[:l_max]
wpix2 = hp.sphtfunc.pixwin(nside2)[:l_max]
_cl_cross = hp.sphtfunc.anafast(flux_map_masked1.filled(),
flux_map_masked2.filled(), lmax=l_max-1, \
iter=5)
wl2 = wb_en*wb_en*wpix1*wpix2
_cl_cross = (_cl_cross/fsky)/(wl2)
cross_txt.write('Cl\t%s\n'%str(list(_cl_cross)).replace('[',''). \
replace(']','').replace(', ', ' '))
_cl_cross_err = np.sqrt(2./((2*_l+1)*fsky))*(_cl_cross)
cross_txt.write('Cl_ERR\t%s\n\n'%str(list(_cl_cross_err)).replace('[',''). \
replace(']','').replace(', ', ' '))
cross_txt.close()
logger.info('Created %s'%(os.path.join(GRATOOLS_OUT, '%s_%s_cross.txt' \
%(out_label, binning_label))))
def make_figures(self,lon,lat,width,Tmax,Pmax,option_part=False):
# os.popen('mkdir -p '+self.out_dir+'/png/'+self.dir_coadd)
# os.popen('mv '+self.out_dir+'/*.npy '+self.out_dir+'/npy/')
if option_part:
map = h.read_map(self.fnameH+'.fits')
h.mollview(map, title='H',max=max(map),min=0)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapH.png')
h.cartview(map,coord='C',rot=[lon,lat],lonra=[-width/2.,width/2.],latra=[-width/2.,width/2.],\
title='H', max=max(map),min=0)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapH_cart.png')
map = h.read_map(self.fnameM+'_CNexcluded.fits')
h.mollview(map, title='M CNexcluded',max=max(map),min=0)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapM_CNexcluded.png')
h.cartview(map,coord='C',rot=[lon,lat],lonra=[-width/2.,width/2.],latra=[-width/2.,width/2.],\
title='M CNexcluded', max=max(map),min=0)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapM_cart_CNexcluded.png')
ind = np.where(map == 1)
ind_non = np.where(map != 1)
map = h.read_map(self.fnameT+'.fits')
h.mollview(map, title='T', max=Tmax, min=-Tmax)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapT.png')
h.cartview(map,coord='C',rot=[lon,lat],lonra=[-width/2.,width/2.],latra=[-width/2.,width/2.],\
title='T', max=Tmax, min=-Tmax)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapT_cart.png')
map = h.read_map(self.fnameQ+'.fits')
h.mollview(map, title='Q',max=Pmax, min=-Pmax)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapQ.png')
h.cartview(map,coord='C',rot=[lon,lat],lonra=[-width/2.,width/2.],latra=[-width/2.,width/2.],\
title='Q', max=Pmax, min=-Pmax)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapQ_cart.png')
map = h.read_map(self.fnameU+'.fits')
h.mollview(map, title='U',max=Pmax,min=-Pmax)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapU.png')
h.cartview(map,coord='C',rot=[lon,lat],lonra=[-width/2.,width/2.],latra=[-width/2.,width/2.],\
title='U', max=Pmax,min=-Pmax)
h.graticule(dpar=10,dmer=10,coord='C')
py.savefig(self.out_dir+'/png/'+self.dir_coadd+'/mapU_cart.png')
import healpy as hp
import matplotlib.pyplot as P
a = hp.fitsfunc.read_map('outputs/kmap.fits')
hp.mollview(a, title='Kmap Mollweide View')
P.savefig('plots/kmap.png')
P.close()
b = hp.fitsfunc.read_map('outputs/amap.fits')
hp.mollview(b, title='Amap Mollweide View')
P.savefig('plots/amap.png')
P.close()
c = hp.fitsfunc.read_map('outputs/pmap.fits')
hp.mollview(c, title='Pmap Mollweide View')
P.savefig('plots/pmap.png')
P.close()
f.create_dataset('rec_cm', data=res)
# # plot pc
# plt.figure()
# fig = plt.figure(1, figsize=(13, 5))
# healpy.mollview(pc[cind], fig=1, title='')
# healpy.graticule(verbose=False)
# fig.savefig(out_dir + 'pc_%d.png' % i)
# plt.close()
# plot pc_sum
plt.figure()
fig = plt.figure(1, figsize=(13, 5))
healpy.mollview(pc_sum[cind],
fig=1,
title='',
min=0,
max=50,
unit='brightness temperature [K]')
healpy.graticule(verbose=False)
fig.savefig(out_dir + 'pc_sum_%d.png' % i)
plt.close()
# plot the difference covariance of pc_sum
plt.figure()
plt.imshow(R_f - np.dot(pc_sum, pc_sum.T) / pc_sum.shape[-1])
plt.colorbar()
plt.savefig(out_dir + 'Rf_diff_%d.png' % i)
plt.close()
# plot res
plt.figure()
nside = 2
npix = hp.nside2npix(nside)
#Uncomment below to make poissonian data
data = np.random.poisson(1, npix)
#Split the data up into energy bins
data_bin1 = data * first_spectral_coeff #This is the number of photons in the first energy bin according to the power law
#Note: Fractional number of photons, maybe non physical?
data_bin2 = data * second_spectral_coeff #This is the number of photons in the second energy bin according to the power law
exposure = np.ones(npix)
max_counts = np.amax(data)
hp.mollview(data_bin1,
title='Fake Data, photons in energy bin 1',
min=0,
max=max_counts)
hp.mollview(data_bin2,
title='Fake Data, photons in energy bin 2',
min=0,
max=max_counts)
hp.mollview(data,
title='Fake Data, total number of photons',
min=0,
max=max_counts)
hp.mollview(data_bin1 + data_bin2,
'Fake Data, photons in energy bin 1 + photons in energy bin 2',
min=0,
max=max_counts)
energy_data = [data_bin1, data_bin2]
pix = hp.ang2pix(NSIDE, theta, phi)
hit_pix, bins = np.histogram(pix,bins=NPIX)
print("Reading Planck data...")
file_path = "/Users/yusuke/program/py_program/CMB/skymap/data/LFI_SkyMap_030-BPassCorrected_0256_R2.01_full.fits"
I_planck = hp.read_map(file_path, field = (0,1,2), dtype=np.float32)#PlanckのRING型データ
I_obs = [I_planck[0][pix], I_planck[1][pix], I_planck[2][pix]]#Planckのデータを観測されるpix順に並び換えた時系列観測データI_obs
npix_array=np.arange(0,NPIX)
npix_split=np.array_split(npix_array, 10)
#s_par = np.array(Parallel(n_jobs=-1, verbose=5)( [delayed(stokes)(i,I_obs) for i in npix_split[number][0:10] ])).T
#s_par = np.array([stokes(i,I_obs) for i in range(507976, 550000) ]).T
s_par = np.array([stokes(i,I_obs) for i in npix_split[number][0:10] ]).T
Runtime = time.time() - start
print("\nFinish!")
print ("Runtime: {0}".format(Runtime) + "[sec]")
print ("Now, data saving...")
path = "/Users/yusuke/program/py_program/CMB/skymap/stokes/reconstruct/Jobs"
np.savez_compressed(path+"/output/sp_{}.npz".format(number), I=s_par[0], Q=s_par[1], V=s_par[2], U=s_par[3])
print ("Complete...")
s_par[0]
I_planck[0]
print ("Show plot!")
hp.mollview(hit_pix, title="Hit count map in Ecliptic coordinates", unit="Hit number")
#hp.mollview(I_planck[0], title="I_STOKES observed by Planck", unit="mK", cmap="jet")
#hp.mollview(map, title="LiteBIRD observation {:.4}-days".format(times/(day+1)), unit="mK",norm="hist",cmap="jet")
#plt.show()
print ("Shut down.")
def test_sim(self):
rank = 0
if self.comm is not None:
rank = self.comm.rank
# make a simple pointing matrix
pointing = OpPointingHpix(nside=self.nside, nest=False, mode="I")
pointing.exec(self.data)
# generate timestreams
op = OpSimDipole(mode="solar", coord="G")
op.exec(self.data)
# make a binned map
# construct distributed maps to store the covariance,
# noise weighted map, and hits
invnpp = DistPixels(
self.data,
nnz=1,
dtype=np.float64,
nest=False,
)
invnpp.data.fill(0.0)
zmap = DistPixels(
self.data,
nnz=1,
dtype=np.float64,
nest=False,
)
zmap.data.fill(0.0)
hits = DistPixels(
self.data,
nnz=1,
dtype=np.int64,
nest=False,
)
hits.data.fill(0)
# accumulate the inverse covariance and noise weighted map.
# Use detector weights based on the analytic NET.
tod = self.data.obs[0]["tod"]
detweights = {}
for d in tod.local_dets:
detweights[d] = 1.0
build_invnpp = OpAccumDiag(detweights=detweights,
invnpp=invnpp,
hits=hits,
zmap=zmap,
name="dipole")
build_invnpp.exec(self.data)
invnpp.allreduce()
hits.allreduce()
zmap.allreduce()
hits.write_healpix_fits(os.path.join(self.outdir, "hits.fits"))
invnpp.write_healpix_fits(os.path.join(self.outdir, "invnpp.fits"))
zmap.write_healpix_fits(os.path.join(self.outdir, "zmap.fits"))
# invert it
covariance_invert(invnpp, 1.0e-3)
invnpp.write_healpix_fits(os.path.join(self.outdir, "npp.fits"))
# compute the binned map, N_pp x Z
covariance_apply(invnpp, zmap)
zmap.write_healpix_fits(os.path.join(self.outdir, "binned.fits"))
if rank == 0:
import matplotlib.pyplot as plt
mapfile = os.path.join(self.outdir, "hits.fits")
data = hp.read_map(mapfile, nest=False)
nt.assert_almost_equal(
data, self.data.comm.ngroups * self.ndet * np.ones_like(data))
outfile = "{}.png".format(mapfile)
hp.mollview(data, xsize=1600, nest=False)
plt.savefig(outfile)
plt.close()
mapfile = os.path.join(self.outdir, "binned.fits")
data = hp.read_map(mapfile, nest=False)
# verify that the extrema are in the correct location
# and have the correct value.
minmap = np.min(data)
maxmap = np.max(data)
nt.assert_almost_equal(maxmap, self.dip_check, decimal=5)
nt.assert_almost_equal(minmap, -self.dip_check, decimal=5)
minloc = np.argmin(data)
maxloc = np.argmax(data)
nt.assert_equal(minloc, self.dip_min_pix)
nt.assert_equal(maxloc, self.dip_max_pix)
outfile = "{}.png".format(mapfile)
hp.mollview(data, xsize=1600, nest=False)
plt.savefig(outfile)
plt.close()
return
judge = np.sign(dif[0] * n_vec[1] - dif[1] * n_vec[0]) #角度psiの正負は外積で判断
cos_psi = inner / (L_dif * L_n)
cos_psi
psi = np.rad2deg(np.arccos(cos_psi)) * judge
psi
#psi[2461]
ang = 180
a = np.where((psi > ang - 1)
& (psi < ang + 1))[0] #-1<ang<1の範囲に軌道ベクトルがきたときの時間[s]
a
pix = hp.ang2pix(NSIDE, orbit[0], orbit[1])
#pix_ = np.concatenate([pix, a,a,a,a,a,a])
#pix_
hit_pix, bins = np.histogram(pix, bins=NPIX)
I_lu = np.zeros(NPIX)
for i in range(times):
for j in range(len(a)):
if i == a[j]:
I_lu[pix[i]] += 10 #a[s]の時は+10
I_lu[pix[i]] += 1
#I_lu[pix[2461]]
hp.mollview(I_lu,
title="Hit count map in Ecliptic coordinates",
unit="Hit number",
cmap="jet")
hp.graticule()
plt.show()
line_strength[pix] = np.nanmedian(field_mean_halpha[idx_line])
i_p = 0
for i_s in np.where(idx_in_field)[0]:
plt.plot(wvl_ccd3, normalized_data_ccd3[i_s,:] + i_p*0.0, color='blue', linewidth=0.5, alpha=0.04)
i_p += 1
if i_p >= 50:
break
plt.xlim(halpha_lim)
plt.ylim((-0.05, 0.05))
plt.savefig('halpha_l{:05.1f}_b{:05.1f}_pix{:.0f}_individual.png'.format(l_center, b_center, pix), dpi=350)
plt.close()
hp.mollview(line_strength, min=-0.01, max=0.01)
plt.savefig('line_strength_map.png', dpi=350)
plt.close()
# plot 2
# idx_plot = np.logical_and(field_mean_hbeta <= 0.02,
# field_mean_hbeta >= -0.02)
# plt.plot(wvl_ccd1, field_mean_hbeta, color='black')
# plt.plot(wvl_ccd1, all_mean_hbeta - field_mean_hbeta, color='blue')
# plt.plot(wvl_ccd1, all_mean_hbeta / field_mean_hbeta, color='blue')
# plt.errorbar(wvl_ccd1, field_mean_hbeta, yerr=field_std_hbeta, markersize=0)
# plt.xlim(hbeta_lim)
# plt.ylim((-0.05, 0.05))
# plt.savefig('hbeta_ra{:03.1f}_dec{:03.1f}.png'.format(ra_center, dec_center), dpi=350)
# plt.close()
dec.append((target.dec))
n += 1
phi = ra
theta = [np.pi / 2 - i for i in dec]
heal_index = hp.ang2pix(NSIDE, theta, phi)
return heal_index
#%%
# taurus A
TauA_ra = 8
TauA_dec = -47.5
TauA_heal_index = findTarget(NSIDE, TauA_ra, TauA_dec, my_location)
m[TauA_heal_index] = 1
#RCW38
RCW38_ra = 5.51
RCW38_dec = 22.0
RCW38_heal_index = findTarget(NSIDE, RCW38_ra, RCW38_dec, my_location)
m[RCW38_heal_index] = 2
#Cen A
CenA_ra = 13.5
CenA_dec = -43
CenA_heal_index = findTarget(NSIDE, CenA_ra, CenA_dec, my_location)
m[CenA_heal_index] = 4
hp.mollview(m, coord=['G', 'E'])
npix = len( map )
ns = np.sqrt( npix/12 )
if verbose:
print ' - determining map size...: %s' %nside
maps = np.zeros( npix, nfreq, dtype=np.float )
print 'reading maps...'
psmask = np.ones( npix )
for ifreq in range(nfreq):
print ' - map ', ifreq+1, ' of', nfreq, ' :'+mapfiles[ifreq]
temp = hp.read_map( mapfiles[ifreq] )
psmask[ int (np.logical_not( (temp == -1.6375e30) or (np.isfinite(temp)) ) ) ] = 0.
maps[*,ifreq] = temp
if check:
hp.mollview(temp, min=-300, max=300., fig=ifreq+1)
else:
npix = n_elements( maps[*,0] )
ns = np.sqrt( npix/12 )
psmask = np.ones( npix )
for ifreq in range(nfreq):
print ' - map ', ifreq+1, ' of', nfreq, ' :'+mapfiles[ifreq]
temp = ( mapfiles[ifreq] )
psmask[ int (np.logical_not( (temp == -1.6375e30) or (np.isfinite(temp)) ) ) ] = 0.
if check:
hp.mollview(temp, min=-300, max=300., fig=ifreq+1)
mask = np.ones( npix )
if False:
lindir_p_96 = '/home/jbm120/nonlinear_forecast/cosmograph/build/nl_runs/r96_P0.13_M1_resc1.0e-3/dust_lensing.1/'
rho_data_lin_96 = loadData(lindir_p_96, 1.0)
rho_interp_lin_96 = rho_interp(rho_data_lin_96)
rhos_lin_96 = rho(rho_interp_lin_96, 0.5)
cls_lin_96 = hp.anafast(rhos_lin_96)
nldir_p_96 = '/home/jbm120/nonlinear_forecast/cosmograph/build/nl_runs/r96_P0.13_M1_resc1.0/dust_lensing/'
rho_data_nl_96 = loadData(nldir_p_96, 1.0)
rho_interp_nl_96 = rho_interp(rho_data_nl_96)
rhos_nl_96 = rho(rho_interp_nl_96, 0.5)
cls_nl_96 = hp.anafast(rhos_nl_96)
hpmin = np.min(rhos_lin_96)
hpmax = np.max(rhos_lin_96)
hp.mollview(rhos_lin_96, min=hpmin, max=hpmax)
plt.savefig('rhos_lin_96.png')
plt.close()
hp.mollview(rhos_nl_96, min=hpmin, max=hpmax)
plt.savefig('rhos_nl_96.png')
plt.close()
# print( ( (rhos_nl_96-np.mean(rhos_nl_96)) - (rhos_lin_96-np.mean(rhos_lin_96)) ) / np.std(rhos_lin_96) )
delta_lin_96 = (rhos_lin_96 - np.mean(rhos_lin_96)) / np.mean(rhos_lin_96)
delta_nl_96 = (rhos_nl_96 - np.mean(rhos_nl_96)) / np.mean(rhos_nl_96)
lindir_p_128 = '/home/jbm120/nonlinear_forecast/cosmograph/build/nl_runs/r128_P0.00000013_M1/dust_lensing.1/'
rho_data_lin_128 = loadData(lindir_p_128, 1000.0)
rho_interp_lin_128 = rho_interp(rho_data_lin_128)
rhos_lin_128 = rho(rho_interp_lin_128, 0.5)
cls_lin_128 = hp.anafast(rhos_lin_128)
sm.computeSpec()
mags = sm.computeMags(canonDict[band])
good = np.where(mags > 0)
if np.size(good[0]) > 10:
modelhp = healplots.healbin(az[good],
alt[good],
mags[good],
nside=nside)
zp = np.median(mags[good] - skydata['sky'][good])
#zps.append(zp)
fig = plt.figure(num=1)
hp.mollview(skyhp + zp,
rot=(0, 90),
sub=(2, 1, 1),
fig=1,
title='Cannon ' + band + ' mjd=%0.2f' % sm.mjd,
min=cmin,
max=cmax)
hp.mollview(modelhp,
rot=(0, 90),
sub=(2, 1, 2),
fig=1,
title='Model. Sun Alt = %0.1f, moon alt = %0.1f' %
(np.degrees(sm.sunAlt), np.degrees(sm.moonAlt)),
min=cmin,
max=cmax)
fig.savefig(
os.path.join(outDir, 'skymovie_%04d' % counter + '.png'))
plt.close(1)
# create the input map (or pick it up if maptyp = checkfile) and broadcast it to ID neq 0
if myid == 0:
map_in = run.map_in
#save a plot of the input map (can remove this/make it optional)
cbar = True
if maptyp == '1pole':
cbar = False
print 'the monopole is ', map_in[0]
plt.figure()
hp.mollview(map_in, cbar=cbar)
plt.savefig('%s/map_in_%s.pdf' % (out_path, maptyp))
plt.close('all')
else:
map_in = None
map_in = comm.bcast(map_in, root=0)
########################## RUN TIMES #########################################
# RUN TIMES : define start and stop time to search in GPS seconds;
# if checkpoint = True make sure to start from end of checkpoint
counter = 0 #counter = number of mins analysed
start = 1126224017 #start = start time of O1 ...
def test_phase(self):
# Choose scan parameters so that we return to the origin.
nobs = 366
precangle = 35.0
spinangle = 55.0
spinperiod = 240
precperiod = 8640
# Precession axis slew
degday = 360.0 / 366.0
samplerate = 1.0 / 60.0
daysamps = 24 * 60
goodsamps = 24 * 60
# goodsamps = 22 * 60
badsamps = daysamps - goodsamps
# hit map
nside = 32
pix = hpx.Pixels(nside)
pdata = np.zeros(12 * nside * nside, dtype=np.int32)
# Only simulate 22 out of 24 hours per observation, in order to test
# that the starting phase is propagated. Put the "gap" at the start
# of each day, so that we can look at the final data point of the
# final observation.
zaxis = np.array([0.0, 0.0, 1.0])
vlast = None
for ob in range(nobs):
firstsamp = ob * daysamps + badsamps
# On the last observation, simulate one extra sample so we get
# back to the starting point.
nsim = goodsamps
if ob == nobs - 1:
nsim += 1
qprec = np.empty(4 * nsim, dtype=np.float64).reshape((-1, 4))
slew_precession_axis(
qprec, firstsamp=firstsamp, samplerate=samplerate, degday=degday
)
boresight = np.empty(4 * nsim, dtype=np.float64).reshape((-1, 4))
satellite_scanning(
boresight,
firstsamp=firstsamp,
samplerate=samplerate,
qprec=qprec,
spinperiod=spinperiod,
spinangle=spinangle,
precperiod=precperiod,
precangle=precangle,
)
v = qa.rotate(boresight, zaxis)
p = pix.vec2ring(v)
pdata[p] += 1
vlast = v[-1]
if self.data.comm.world_rank == 0:
import matplotlib.pyplot as plt
hitsfile = os.path.join(self.outdir, "tod_satellite_hits.fits")
if os.path.isfile(hitsfile):
os.remove(hitsfile)
hp.write_map(hitsfile, pdata, nest=False, dtype=np.int32)
outfile = "{}.png".format(hitsfile)
hp.mollview(pdata, xsize=1600, nest=False)
plt.savefig(outfile)
plt.close()
np.testing.assert_almost_equal(vlast[0], 0.0)
np.testing.assert_almost_equal(vlast[1], -1.0)
np.testing.assert_almost_equal(vlast[2], 0.0)
return
def plot_density(input_dir_list,
mag,
i_bound,
i_fig,
rows=3,
cols=2,
title_list=None):
n_pix = hp.nside2npix(NSIDE)
margins = (0.01, 0.01, 0.04, 0.01)
dtype = np.dtype([('ct', int)])
tag_list = []
legend = None
tag = '%s_%d' % (mag, i_bound)
ct_arr = {}
for input_dir in input_dir_list:
list_of_files = os.listdir(input_dir)
ct_arr[input_dir] = np.zeros(n_pix)
for file_name in list_of_files:
if not tag in file_name:
continue
full_name = os.path.join(input_dir, file_name)
with open(full_name, 'r') as input_file:
if legend is None:
legend = input_file.readlines()[0]
print legend
else:
assert legend == input_file.readlines()[0]
data = np.genfromtxt(full_name, dtype=dtype)
assert len(data['ct']) == n_pix
ct_arr[input_dir] += data['ct']
c_min = None
c_max = None
for input_dir in input_dir_list:
lmin = ct_arr[input_dir].min()
lmax = ct_arr[input_dir].max()
if c_min is None or lmin < c_min:
c_min = lmin
if c_max is None or lmax > c_max:
c_max = lmax
for input_dir, title in zip(input_dir_list, title_list):
if title_list is None:
fig_title = legend.strip().replace('# ', '')
else:
fig_title = legend.strip().replace('# ', '') + ' ' + title
hp.mollview(ct_arr[input_dir],
title=fig_title,
cbar=False,
margins=margins,
sub=(rows, cols, i_fig))
hp.graticule(dpar=10, dmer=20, verbose=False)
i_fig += 1
ax = plt.gca()
im = ax.get_images()[0]
cticks = np.arange(c_min, c_max, 0.2 * (c_max - c_min))
clabels = ['%.2e' % cc for cc in cticks]
cb = plt.colorbar(im)
cb.set_ticks(cticks)
cb.set_ticklabels(clabels)
cb.set_clim(vmin=c_min, vmax=c_max)
cb.ax.tick_params(labelsize=10)
cb.draw_all()
return i_fig
def healpix(filename, plotDir, data_out):
bayestar = True
if bayestar:
healpix_data = hp.read_map(filename, field=(0, 1, 2, 3))
distmu_data = healpix_data[1]
diststd_data = healpix_data[2]
prob_data = healpix_data[0]
norm_data = healpix_data[3]
plotName = os.path.join(plotDir, 'mollview.png')
vmin = np.min(prob_data)
vmax = np.max(prob_data)
hp.mollview(prob_data, min=vmin, max=vmax, title="", unit='Likelihood')
hp.graticule()
plt.show()
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview.eps')
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
distmu_data[distmu_data < 0] = np.inf
distmu_data_cut = distmu_data[~np.isinf(distmu_data)]
plotName = os.path.join(plotDir, 'mollview_dist.png')
vmin = np.min(distmu_data_cut)
vmax = np.max(distmu_data_cut)
hp.mollview(distmu_data,
min=vmin,
max=vmax,
title="",
unit='Distance [Mpc]')
hp.graticule()
plt.show()
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview_dist.eps')
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview_dist.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
diststd_data[diststd_data < 0] = np.inf
diststd_data_cut = diststd_data[~np.isinf(diststd_data)]
plotName = os.path.join(plotDir, 'mollview_dist_std.png')
vmin = np.min(diststd_data_cut)
vmax = np.max(diststd_data_cut)
hp.mollview(diststd_data,
min=vmin,
max=vmax,
title="",
unit='Distance [Mpc]')
hp.graticule()
plt.show()
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview_dist_std.eps')
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview_dist_std.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
distmu_data = hp.ud_grade(distmu_data, nside)
diststd_data = hp.ud_grade(diststd_data, nside)
norm_data = hp.ud_grade(norm_data, nside)
else:
prob_data = hp.read_map(filename, field=0)
prob_data = prob_data / np.sum(prob_data)
prob_data = hp.ud_grade(prob_data, nside)
prob_data = prob_data / np.sum(prob_data)
indexes = np.where(prob_data < np.max(prob_data) * 0.01)[0]
prob_data_nan = prob_data.copy()
prob_data_nan[indexes] = np.nan
vmin = np.nanmin(prob_data_nan)
vmax = np.nanmax(prob_data_nan)
plotName = os.path.join(plotDir, 'mollview_small.png')
hp.mollview(prob_data_nan, min=vmin, max=vmax, title="", unit='Likelihood')
hp.graticule()
plt.show()
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview_small.eps')
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'mollview_small.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
npix = hp.nside2npix(nside)
theta, phi = hp.pix2ang(nside, np.arange(npix))
ra = np.rad2deg(phi)
dec = np.rad2deg(0.5 * np.pi - theta)
absm = np.random.rand(len(
data_out["ra"]), ) * (maxabsm - minabsm) + minabsm
data_out["absm"] = absm
fade = np.random.rand(len(
data_out["ra"]), ) * (maxfade - minfade) + minfade
data_out["fade"] = fade
# Run MC
print "Ra: %.5f %.5f" % (np.min(data_out["ra"]), np.max(data_out["ra"]))
print "Declination: %.5f %.5f" % (np.min(
data_out["dec"]), np.max(data_out["dec"]))
print "Distance: %.5f %.5f" % (np.min(
data_out["dist"]), np.max(data_out["dist"]))
print "Absolute Magnitude: %.5f %.5f" % (np.min(
data_out["absm"]), np.max(data_out["absm"]))
if telescope == "combined":
# number of dimensions our problem has
parameters = [
"n_PS1", "cl_PS1", "r_PS1", "n_ATLAS", "cl_ATLAS", "r_ATLAS"
]
else:
# number of dimensions our problem has
parameters = ["n", "cl", "r"]
n_params = len(parameters)
global prob_data, distmu_data
if telescope == "combined":
pymultinest.run(myloglike_multi,
myprior_multi,
n_params,
importance_nested_sampling=False,
resume=True,
verbose=True,
sampling_efficiency='parameter',
n_live_points=1000,
outputfiles_basename='%s/2-' % plotDir,
evidence_tolerance=0.001,
multimodal=False)
else:
pymultinest.run(myloglike,
myprior,
n_params,
importance_nested_sampling=False,
resume=True,
verbose=True,
sampling_efficiency='parameter',
n_live_points=1000,
outputfiles_basename='%s/2-' % plotDir,
evidence_tolerance=0.001,
multimodal=False)
# lets analyse the results
a = pymultinest.Analyzer(n_params=n_params,
outputfiles_basename='%s/2-' % plotDir)
s = a.get_stats()
import json
# store name of parameters, always useful
with open('%sparams.json' % a.outputfiles_basename, 'w') as f:
json.dump(parameters, f, indent=2)
# store derived stats
with open('%sstats.json' % a.outputfiles_basename, mode='w') as f:
json.dump(s, f, indent=2)
print()
print("-" * 30, 'ANALYSIS', "-" * 30)
print("Global Evidence:\n\t%.15e +- %.15e" %
(s['nested sampling global log-evidence'],
s['nested sampling global log-evidence error']))
#multifile= os.path.join(plotDir,'2-.txt')
multifile = get_post_file(plotDir)
data = np.loadtxt(multifile)
#loglikelihood = -(1/2.0)*data[:,1]
#idx = np.argmax(loglikelihood)
if telescope == "combined":
n_PS1 = data[:, 0]
cl_PS1 = data[:, 1]
r_PS1 = data[:, 2]
n_ATLAS = data[:, 3]
cl_ATLAS = data[:, 4]
r_ATLAS = data[:, 5]
loglikelihood = data[:, 6]
idx = np.argmax(loglikelihood)
n_PS1_best = data[idx, 0]
cl_PS1_best = data[idx, 1]
r_PS1_best = data[idx, 2]
n_ATLAS_best = data[idx, 3]
cl_ATLAS_best = data[idx, 4]
r_ATLAS_best = data[idx, 5]
image_optimal_array = numimages_combine(prob_data, distmu_data,
data_out, n_PS1_best,
cl_PS1_best, r_PS1_best,
n_ATLAS_best, cl_ATLAS_best,
r_ATLAS_best)
image_optimal_array_sorted = np.sort(image_optimal_array)
image_nominal_array = numimages_combine(prob_data, distmu_data,
data_out, 0.0, 0.99, 0.0, 0.0,
0.99, 0.0)
image_nominal_array_sorted = np.sort(image_nominal_array)
image_known_array = numknown(prob_data, data_out, PS1_Telescope_T,
PS1_Telescope_m)
image_known_array_sorted = np.sort(image_known_array)
filename = os.path.join(plotDir, 'samples.dat')
fid = open(filename, 'w+')
for i, j, k, l, m, o in zip(n_PS1, cl_PS1, r_PS1, n_ATLAS, cl_ATLAS,
r_ATLAS):
fid.write('%.5f %.5f %.5f %.5f %.5f %.5f\n' % (i, j, k, l, m, o))
fid.close()
filename = os.path.join(plotDir, 'best.dat')
fid = open(filename, 'w')
fid.write('%.5f %.5f %.5f %.5f %.5f %.5f\n' %
(n_PS1_best, cl_PS1_best, r_PS1_best, n_ATLAS_best,
cl_ATLAS_best, r_ATLAS_best))
fid.close()
plt.figure(figsize=(12, 10))
bins1, hist1 = hist_results(n_PS1)
bins2, hist2 = hist_results(n_ATLAS)
#plt.plot(bins1, np.cumsum(hist1),'k',label='PS1')
#plt.plot(bins2, np.cumsum(hist2),'k--',label='ATLAS')
plt.plot(bins1, hist1, 'k', label='PS1')
plt.plot(bins2, hist2, 'k--', label='ATLAS')
plt.legend(loc='best')
#plt.xlim([10,1e6])
#plt.ylim([0,1.0])
plt.xlabel('Likelihood Powerlaw Index')
plt.ylabel('Probability Density Function')
plt.show()
plotName = os.path.join(plotDir, 'n.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
plt.figure(figsize=(12, 10))
bins1, hist1 = hist_results(cl_PS1)
bins2, hist2 = hist_results(cl_ATLAS)
#plt.plot(bins1, np.cumsum(hist1),'k',label='PS1')
#plt.plot(bins2, np.cumsum(hist2),'k--',label='ATLAS')
plt.plot(bins1, hist1, 'k', label='PS1')
plt.plot(bins2, hist2, 'k--', label='ATLAS')
plt.legend(loc='best')
#plt.xlim([10,1e6])
#plt.ylim([0,1.0])
plt.xlabel('Likelihood Confidence Level')
plt.ylabel('Probability Density Function')
plt.show()
plotName = os.path.join(plotDir, 'cl.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
plt.figure(figsize=(12, 10))
bins1, hist1 = hist_results(r_PS1)
bins2, hist2 = hist_results(r_ATLAS)
#plt.plot(bins1, np.cumsum(hist1),'k',label='PS1')
#plt.plot(bins2, np.cumsum(hist2),'k--',label='ATLAS')
plt.plot(bins1, hist1, 'k', label='PS1')
plt.plot(bins2, hist2, 'k--', label='ATLAS')
plt.legend(loc='best')
#plt.xlim([10,1e6])
#plt.ylim([0,1.0])
plt.xlabel('Distance Powerlaw Index')
plt.ylabel('Probability Density Function')
plt.show()
plotName = os.path.join(plotDir, 'r.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
else:
n = data[:, 0]
cl = data[:, 1]
r = data[:, 2]
loglikelihood = data[:, 3]
idx = np.argmax(loglikelihood)
n_best = data[idx, 0]
cl_best = data[idx, 1]
r_best = data[idx, 2]
image_optimal_array = numimages(prob_data, distmu_data, data_out,
Telescope_T, Telescope_m, n_best,
cl_best, r_best)
image_optimal_array_sorted = np.sort(image_optimal_array)
image_nominal_array = numimages(prob_data, distmu_data, data_out,
Telescope_T, Telescope_m, 0.0, 0.99,
0.0)
image_nominal_array_sorted = np.sort(image_nominal_array)
image_known_array = numknown(prob_data, data_out, Telescope_T,
Telescope_m)
image_known_array_sorted = np.sort(image_known_array)
filename = os.path.join(plotDir, 'samples.dat')
fid = open(filename, 'w+')
for i, j, k in zip(n, cl, r):
fid.write('%.5f %.5f %.5f\n' % (i, j, k))
fid.close()
filename = os.path.join(plotDir, 'best.dat')
fid = open(filename, 'w')
fid.write('%.5f %.5f %.5f\n' % (n_best, cl_best, r_best))
fid.close()
plt.figure(figsize=(12, 10))
bins1, hist1 = hist_results(n)
plt.plot(bins1, hist1)
plt.xlabel('Powerlaw Index')
plt.ylabel('Probability Density Function')
plt.show()
plotName = os.path.join(plotDir, 'n.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
plt.figure(figsize=(12, 10))
bins1, hist1 = hist_results(cl)
plt.plot(bins1, hist1)
plt.xlabel('Powerlaw Index')
plt.ylabel('Probability Density Function')
plt.show()
plotName = os.path.join(plotDir, 'cl.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
plt.figure(figsize=(12, 10))
bins1, hist1 = hist_results(r)
plt.plot(bins1, hist1)
plt.xlabel('Powerlaw Index')
plt.ylabel('Probability Density Function')
plt.show()
plotName = os.path.join(plotDir, 'r.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
ns = np.linspace(0.01, 2.0, 50)
cls = np.linspace(0.5, 1.0, 50)
images_detected = np.zeros((len(ns), len(cls)))
images_T = np.zeros((len(ns), len(cls)))
for ii, n in enumerate(ns):
for jj, cl in enumerate(cls):
image_array = numimages(prob_data, distmu_data, data_out,
Telescope_T, Telescope_m, n, cl, 0.0)
image_array_sorted = np.sort(image_array)
tmax = tmax = data_out["fade"] * 3600
image_detected = float(len(
np.where(image_array < tmax)[0])) / float(len(image_array))
index = np.floor(len(image_array) * 0.5)
image_T = image_array_sorted[index]
images_detected[ii, jj] = image_detected
images_T[ii, jj] = image_T / 3600.0
NS, CLS = np.meshgrid(ns, cls)
vmin = np.min(images_detected)
vmax = np.max(images_detected)
plotName = os.path.join(plotDir, 'images_detected.png')
plt.figure()
plt.pcolor(NS,
CLS,
images_detected.T,
vmin=vmin,
vmax=vmax,
cmap=plt.get_cmap('rainbow'))
cbar = plt.colorbar()
cbar.ax.set_ylabel('Percentage of detections')
plt.xlabel('Power Law Index')
plt.ylabel('Confidence Level')
plt.xlim([0.01, 2.0])
plt.ylim([0.5, 1.0])
plt.show()
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'images_detected.eps')
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'images_detected.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
vmin = 0.0
vmax = 10.0
plotName = os.path.join(plotDir, 'images_T.png')
plt.figure()
plt.pcolor(NS,
CLS,
images_T.T,
vmin=vmin,
vmax=vmax,
cmap=plt.get_cmap('rainbow'))
cbar = plt.colorbar()
cbar.ax.set_ylabel('Median detection time [hours]')
plt.xlabel('Power Law Index')
plt.ylabel('Confidence Level')
plt.xlim([0.01, 2.0])
plt.ylim([0.5, 1.0])
plt.show()
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'images_T.eps')
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'images_T.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
nums = np.arange(0, len(image_nominal_array_sorted))
nums[:] = 1.0
nums = nums / np.sum(nums)
nums_cumsum = np.cumsum(nums)
plotName = os.path.join(plotDir, 'optimization.png')
plt.figure()
plt.semilogx(image_nominal_array_sorted,
100 * nums_cumsum,
'k--',
label='Naive')
plt.semilogx(image_optimal_array_sorted,
100 * nums_cumsum,
'r.-',
label='Optimal')
plt.semilogx(image_known_array_sorted,
100 * nums_cumsum,
'c',
label='Known')
plt.legend(loc=2)
plt.xlim([10, 1e6])
plt.ylim([0, 100.0])
plt.xlabel('Time [s]')
plt.ylabel('Percentage of imaged counterparts')
plt.show()
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'optimization.eps')
plt.savefig(plotName, dpi=200)
plotName = os.path.join(plotDir, 'optimization.pdf')
plt.savefig(plotName, dpi=200)
plt.close('all')
filename = os.path.join(plotDir, 'images.dat')
fid = open(filename, 'w+')
for i, j, k, l in zip(nums_cumsum, image_nominal_array_sorted,
image_optimal_array_sorted,
image_known_array_sorted):
fid.write('%.5e %.5e %.5e %.5e\n' % (i, j, k, l))
fid.close()
import numpy as np
import pylab as py
import healpy as h
import sys
'''
'''
filename1 = '/home/cmb/tmatsumu/develop/LiteBIRD/projects/LB_SYSPL_v4.1_release/Simulator/data_proj/SimedMaps/RunLog/20160818_140GHz_TQU_1/coadd_map/coadd_map1/mapAA_CNexcluded'
filename2 = '/home/cmb/tmatsumu/develop/LiteBIRD/projects/LB_SYSPL_v4.1_release/Simulator/data_proj/SimedMaps/RunLog/20160818_140GHz_TQU_2/coadd_map/coadd_map1/mapAA_CNexcluded'
mapin1 = h.read_map(filename1 + '.fits')
mapin2 = h.read_map(filename2 + '.fits')
h.mollview(mapin1 / mapin2, max=2000, min=1)
py.savefig('AAratio.png')
#h.mollview(mapin1/mapin2,norm='log')
#py.savefig('AAratio_log.png')
import healpy
import matplotlib.pypot as plt
import scipy
betw = lambda x, x1, x2: (x > x1) & (x < x2)
exec idlsave.restore('gaia_scan_512_gal.psav')
#locs=np.r_[np.arange(48)/24.,np.arange(2,365),np.arange(365,5*365,5)]
locs = np.r_[1, 10, 100, 500]
def doit(x):
return scipy.histogram(x, locs)[0]
superres = [doit(_) for _ in obstimes]
arr = np.array(superrres)
arr = np.array(superres)
for i in range(nx):
plt.clf()
healpy.mollview((arr[:, :i]).sum(axis=1),
fig=1,
nest=True,
hold=True,
title='%.03f days' % locs[i],
min=0,
max=max(((arr[:, :i]).sum(axis=1)).max(), 1),
xsize=2000)
plt.savefig('xx_%04d.png' % i, dpi=600)
tfiles = [ gmodel.galaxy.cmb.filename, gmodel.galaxy.dust.filename, gmodel.galaxy.freefree.filename,
gmodel.galaxy.sync.filename, h.filename, dir+'map_monopole_ns0128.fits', dir+'map_xdipole_ns0128.fits',
dir+'map_ydipole_ns0128.fits', dir+'map_zdipole_ns0128.fits' ]
map = getattr( data, 'f'+freq )
r = map_regression( map.imap.map, tfiles, rms=map.irms.map, maskfile=setup.mask.filename, return_res=True, return_chi2=True )
chisq_nod.append( str("%.3f" % r[3]) )
c2 += r[3]
if plot_gnom:
ccc = r[0][5] + gmodel.galaxy.dipole_x.map*r[0][6] + \
gmodel.galaxy.dipole_y.map*r[0][7] + \
gmodel.galaxy.dipole_z.map*r[0][8]
ccc = asinh10( ccc )
# ccc[bpix] = hp.UNSEEN
hp.mollview( ccc, title=freq, fig=1)
hp.graticule( dpar=20, dmer=20 )
ccc = asinh10( map.imap.map )
hp.mollview( ccc, title=freq, fig=3)
hp.graticule( dpar=20, dmer=20 )
# freq_min[ freq ] = r
mnpnt_nod['f'+freq+'_cmb'] = r[0][0]
mnpnt_nod['f'+freq+'_dust'] = r[0][1]
mnpnt_nod['f'+freq+'_freefree'] = r[0][2]
mnpnt_nod['f'+freq+'_sync'] = r[0][3]
mnpnt_nod['f'+freq+'_haze'] = r[0][4]
mnpnt_nod['f'+freq+'_monopole'] = r[0][5]
mnpnt_nod['f'+freq+'_dipole_x'] = r[0][6]
mnpnt_nod['f'+freq+'_dipole_y'] = r[0][7]
idx = (zred != -1.)
zred = zred[idx]
idy = (zred <= 0.33)
zred = zred[idy]
mu_r = -1.0 + 2.*np.random.random(size = Nsize)
phi_r = 2.0*np.pi*np.random.random(size = Nsize)
theta_r = np.arccos(mu_r)
pix = healpy.pixelfunc.ang2pix(2048, theta_r, phi_r)
mask = (seln_func[pix] == 1) #Select only points within the seln_func
theta_r = theta_r[mask]
phi_r = phi_r[mask]
zred_r = zred[np.random.permutation(phi_r.size) % zred.size] #Produce 'random' redshifts
fig = plt.figure(1)
healpy.mollview(seln_func,norm = 'hist', cmap = 'PRGn')
fig.savefig(sel_fig)
fig = plt.figure(2)
healpy.mollview(seln_func, norm = 'hist', cmap = 'PRGn')
healpy.projscatter(planck_theta, planck_phi, s = 1, lw = 0)
fig.savefig(bcg_fig)
fig = plt.figure(3)
healpy.mollview(seln_func, norm = 'hist', cmap = 'PRGn')
healpy.projscatter(theta_r, phi_r, s = 1, lw = 0)
fig.savefig(dist_fig)
# Now convert using astropy coordinates
c = SkyCoord(l = phi_r, b = np.pi/2 - theta_r, frame = 'galactic', unit = 'radian')
output = np.transpose([c.icrs.ra.deg,c.icrs.dec.deg,zred_r])
invlap = 1.0 / ls / (ls + 1.0)
invlap[0] = 0.0 # zero monopole (?)
dPlm = hp.almxfl(dPlm, invlap)
# contribution to map from each radial bin
print("Computing dT_in_bin.")
# total map is this integrated in all bins * geometric factors...
chi_bin = (bin_lower_chi+bin_upper_chi)/2.0
z_bin = zofchi(chi_bin)
a_bin = 1.0 / (1.0 + z_bin)
H_bin = Hofz(z_bin)/c
dT_ML_lms += 3.0 * d_chi * (a_bin*H_bin)**2 * chi_bin * dPlm
# Store & Plot result.
dT_ML = hp.alm2map(dT_ML_lms, NSIDE)
hp.mollview(dT_ML)
plt.title('Moving Lens sky')
plt.savefig('Tmap_ML.png')
plt.close()
hp.fitsfunc.write_map('ML.fits', dT_ML, overwrite=True)
# Plot power spectra
CMBTuk = 2750000.
CMB_alms = hp.fitsfunc.read_alm('lensed_alm.fits').astype(np.complex)/CMBTuk
MLPS = hp.anafast(dT_ML)
CMBPS = hp.alm2cl(CMB_alms)
def Ls(PS) :
return np.arange(len(PS))
def norm(PS) :
# result in an error if LaTeX is not installed on your system. In that case,
# you can set usetex to False.
from astroML.plotting import setup_text_plots
setup_text_plots(fontsize=8, usetex=True)
#------------------------------------------------------------
# First plot an example pixellization
# Prepare the healpix pixels
NSIDE = 4
m = np.arange(hp.nside2npix(NSIDE))
print("number of pixels:", len(m))
# Plot the pixelization
fig = plt.figure(1, figsize=(5, 3.75))
hp.mollview(m, nest=True, title="HEALPix Pixels (Mollweide)", fig=1)
# remove colorbar: we don't need it for this plot
fig.delaxes(fig.axes[1])
#------------------------------------------------------------
# Next plot the wmap pixellization
wmap_unmasked = fetch_wmap_temperatures(masked=False)
# plot the unmasked map
fig = plt.figure(2, figsize=(5, 3.75))
hp.mollview(wmap_unmasked,
min=-1,
max=1,
title='Raw WMAP data',
unit=r'$\Delta$T (mK)',
print('number of galaxies randoms: ', len(ra_rand_g))
print('number of matter randoms: ', len(ra_rand_m))
if make_plots:
def eq2ang(ra, dec):
phi = ra * np.pi / 180.
theta = (np.pi / 2.) - dec * (np.pi / 180.)
return theta, phi
theta_m, phi_m = eq2ang(ra_rand_m, dec_rand_m)
ind_m_f = hp.ang2pix(128, theta_m, phi_m)
mask_m = np.zeros(hp.nside2npix(128))
mask_m[ind_m_f] = 1
plt.figure()
hp.mollview(mask_m)
plt.savefig(save_dir + 'rand_m_sky.png')
# pdb.set_trace()
galaxy_param_dict = {'RA': ra_g, 'DEC': dec_g, 'R': r_g, 'JK': jk_g}
galaxy_random_param_dict = {
'RA': ra_rand_g,
'DEC': dec_rand_g,
'R': r_rand_g,
'JK': jk_rand_g
}
matter_param_dict = {'RA': ra_m, 'DEC': dec_m, 'R': r_m, 'JK': jk_m}
matter_random_param_dict = {
'RA': ra_rand_m,
'DEC': dec_rand_m,
# In[3]:
get_ipython().magic(u'matplotlib inline')
import healpy
import matplotlib.pyplot as plt
#stack all maps
crMap = np.zeros(49152)
for pid in M.getParticleIds():
energies = M.getEnergies(int(pid))
for i, energy in enumerate(energies):
crMap += M.getMap(int(pid), energy * crpropa.eV)
#plot maps using healpy
healpy.mollview(map=crMap, title='Unlensed')
plt.savefig('unlensed_map.png')
# ## Apply Galactic Lenses
#
# To apply a lens to a map, a lens object needs to be created and then applied to the map. The normalization of the lens ensures that the lens does not distort the spectra.
# In[5]:
get_ipython().magic(u'matplotlib inline')
# The lens can be downloaded here: https://crpropa.desy.de/ --> Additional downloads
lens = crpropa.MagneticLens('pathto/lens.cfg')
lens.normalizeLens()
M.applyLens(lens)
galm = ct.rearange_alm(
lmax,
alm_data) #preoblikovanje tabele podatkov v obliko, ki jo vrne map2alm
#g v imenu definiran za galaktične koordinate
#print(galm)
gmapa = hp.alm2map(galm, nside=64) #kreacija mape iz galm koeficientov
#gmapa=gmapa*10**-2 #renormalizacija (še ne pravilna)
b = cm.seismic #
b.set_under("w") #
hp.mollview(gmapa,
cmap=b,
title='Planck Kappa mapa (galaktični sistem)',
cbar=True,
xsize=1400) #izris mape
#ct.mollaxes()
hp.graticule(coord=('E')) #
plt.show()
#alm_check=hp.map2alm(gmapa,lmax=lmax) #preveritev, če vrne map2alm vsaj podobne koeficiente kot v originalnih podatkih (vrne renormalizirane, ker vrnejo isto obliko mape z renormaliziranimi vrednostmi)
b, l, aomega = ct.eq2gal(0, 90)
hp.rotate_alm(galm, psi=l, theta=b, phi=aomega, lmax=lmax)
emapa = hp.alm2map(galm, nside=64) #kreacija mape iz ealm koeficientov
#emapa=emapa*10**-2 #renormalizacija (še ne pravilna)
