def get_hpmask_subpix_indices(submask_nside, submask_hpix, submask_border, nside_mask, hpix):
"""
"""
nside_cutref = np.clip(submask_nside * 4, 256, nside_mask)
# Find out which cutref pixels are inside the main pixel
theta, phi = hp.pix2ang(nside_cutref, np.arange(hp.nside2npix(nside_cutref)))
ipring_coarse = hp.ang2pix(submask_nside, theta, phi)
inhpix, = np.where(ipring_coarse == submask_hpix)
# If there is a border, we need to find the boundary pixels
if submask_border > 0.0:
boundaries = hp.boundaries(submask_nside, submask_hpix, step=nside_cutref/submask_nside)
# These are all the pixels that touch the boundary
for i in xrange(boundaries.shape[1]):
pixint = hp.query_disc(nside_cutref, boundaries[:, i],
np.radians(submask_border), inclusive=True, fact=8)
inhpix = np.append(inhpix, pixint)
# Need to uniqify here because of overlapping pixels
inhpix = np.unique(inhpix)
# And now choose just those depthmap pixels that are in the inhpix region
theta, phi = hp.pix2ang(nside_mask, hpix)
ipring = hp.ang2pix(nside_cutref, theta, phi)
_, use = esutil.numpy_util.match(inhpix, ipring)
return use
def scrambler(data, nSide, nBGResample, method):
# Setup maps
temp_maps = {}
nPixels = hp.nside2npix(nSide)
for key in ['Local', 'Data', 'BG']:
temp_maps[key] = zeros(nPixels)
# Begin looping through data
mjd = data['mjd']
theta = data['ShowerPlane_zenith']
phi = data['ShowerPlane_azimuth']
# Fill local and data maps
local_pix = hp.ang2pix(nSide, theta, phi)
dec, ra = array(map(l2e, mjd, theta, phi)).T
data_pix = hp.ang2pix(nSide, dec, ra)
for i in range(len(local_pix)):
temp_maps['Local'][local_pix[i]] += 1.0
temp_maps['Data'][data_pix[i]] += 1.0
# Function for getting nBGResample background counts with random times
def getBG(th, ph):
rndMJD = random.choice(mjd, nBGResample)
dec, ra = array([l2e(mjd_one, th, ph) for mjd_one in rndMJD]).T
pixelID = hp.ang2pix(nSide, dec, ra)
return pixelID
# Fill background map
bg_pix = array(map(getBG, theta, phi)).flatten()
for pix in bg_pix:
temp_maps['BG'][pix] += 1.0
return temp_maps
def __init__(self, pts, ipix=None, nside=None):
self._ipix = ipix
self._nside = nside
self._pts = pts
if len(pts) <= 1 or nside >= 1<<29:
# Stop here. Either there is only one point left, or we
# are in danger of exceeding the healpy limit on nside
self._sub_grids = None
elif ipix is None or nside is None:
nside = 1
sub_ipts = [hp.ang2pix(1, np.pi/2.0-pt[1], pt[0], nest=True) for pt in pts]
sub_grids = []
for i in range(12):
subp = [pt for pt, ipt in zip(pts, sub_ipts) if ipt == i]
sub_grids.append(_Hp_adaptive_grid_pixel(subp, i, 1))
self._sub_grids = sub_grids
else:
sub_ipix = [4*ipix + i for i in range(4)]
sub_nside = 2*nside
sub_ipts = [hp.ang2pix(sub_nside, np.pi/2.0 - pt[1], pt[0], nest=True) for pt in pts]
sub_grids = []
for sip in sub_ipix:
subp = [pt for pt, ipt in zip(pts, sub_ipts) if ipt == sip]
sub_grids.append(_Hp_adaptive_grid_pixel(subp, sip, sub_nside))
self._sub_grids = sub_grids
def Pixel_separator(Halo_data,Input_Para,General_Prop):
import healpy as hp
from XCat_Objects import DtoR, Halo_Object
from XCat_Utilities import Read_Integer_Input
nside = 1
while ( Input_Para.SkySqrDeg < 64800.0/float(hp.nside2npix(2*nside)) ):
nside = 2*nside
if (General_Prop.Hala_data_existence):
n = Halo_data.number_of_halos
kp= Read_Integer_Input("We have %i halos in this slice which one you want to exctract ? "%n)
kp= kp - 1
while(kp > (n-1) or kp < 0 ):
print "Invalid Number."
kp= Read_Integer_Input("Please choose an integer between 1 and %i : "%n)
kp= kp - 1
k = hp.ang2pix(nside,DtoR*(90.0-Halo_data.DEC[kp]),DtoR*(Halo_data.RA[kp]))
Pix_Halo_data = Halo_Object()
for i in range(n):
if ( k == hp.ang2pix(nside,DtoR*(90.0-Halo_data.DEC[i]),DtoR*(Halo_data.RA[i])) ):
Pix_Halo_data.add_single_data(Halo_data,i)
Pix_Halo_data.update_halo_data
General_Prop.update
General_Prop.Pix_separator = True
General_Prop.Pix_separator_update(nside,k)
else:
"First you need to add a halo catalog ..."
Pix_Halo_data = None
raw_input("Press enter to continue ... ")
return Pix_Halo_data
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 fillLivetime(self):
for i, cth in enumerate(self._ctheta_axis.center):
dcostheta = self._ctheta_axis.width[i]
if self._src_type == 'iso':
self._tau[i] = dcostheta
elif self._src_type == 'isodec':
sinlat = np.linspace(-1,1,48)
m = self._ltmap[:,i]
self._tau[i] = 0
for s in sinlat:
lat = np.arcsin(s)
th = np.pi/2. - lat
ipix = healpy.ang2pix(64,th,0,nest=True)
self._tau[i] += m[ipix]
else:
th = np.pi/2. - self._lonlat[1]*np.pi/180.
phi = self._lonlat[0]*np.pi/180.
m = self._ltmap[:,i]
ipix = healpy.ang2pix(64,th,phi,nest=True)
# tau = healpy.get_interp_val(m,th,phi,nest=True)
self._tau[i] = m[ipix]
def is_in(self, ra, decl):
"""
Check if position is in the MOC map.
ra, decl - sky coordinates (or lists of coordinates).
"""
theta = 0.5*np.pi - np.radians(decl)
phi = np.radians(ra)
keys = self.healpix.keys()
keys.sort()
if isinstance(ra, float):
for level in keys:
healpix_cell = healpy.ang2pix(2**level, theta, phi, nest=True)
if healpix_cell in self.healpix[level]:
return True
return False
else:
result = np.zeros(len(ra), dtype=bool)
for level in keys:
healpix_cell = healpy.ang2pix(2**level, theta, phi, nest=True)
cellcheck = [cell in self.healpix[level] for cell in healpix_cell]
if cellcheck.any():
result = result + cellcheck
if result.all():
return result
return result
def cscrambler(data, nSide, nBGResample, method):
# Setup maps
test = ShowerLLH.TimeScramble()
temp_maps = {}
nPixels = hp.nside2npix(nSide)
#for key in ['Local', 'Data', 'BG']:
for key in ['Data', 'BG']:
temp_maps[key] = zeros(nPixels)
# Begin looping through data
mjd = data['mjd']
theta = data['ShowerPlane_zenith']
phi = data['ShowerPlane_azimuth']
# Fill local and data maps
local_pix = hp.ang2pix(nSide, theta, phi)
dec, ra = array(map(l2e, mjd, theta, phi)).T
data_pix = hp.ang2pix(nSide, dec, ra)
for i in range(len(local_pix)):
#temp_maps['Local'][local_pix[i]] += 1.0
temp_maps['Data'][data_pix[i]] += 1.0
# Fill background map
bg = test.cscramble(mjd, theta, phi, nSide, nBGResample, method)
temp_maps['BG'] = asarray(bg)
return temp_maps
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 setUp(self):
fixture_name = os.path.splitext(os.path.basename(__file__))[0]
self.outdir = create_outdir(self.comm, fixture_name)
# Create one observation per group, and each observation will have
# one detector per process and a single chunk.
self.data = create_distdata(self.comm, obs_per_group=1)
self.ndet = self.data.comm.group_size
self.rate = 20.0
# Create detectors with default properties
dnames, dquat, depsilon, drate, dnet, dfmin, dfknee, dalpha = \
boresight_focalplane(self.ndet, samplerate=self.rate)
# Pixelization
self.nside = 64
self.npix = 12 * self.nside**2
self.subnside = 16
if self.subnside > self.nside:
self.subnside = self.nside
self.subnpix = 12 * self.subnside * self.subnside
# Samples per observation
self.totsamp = self.npix
# Dipole parameters
self.solar_speed = 369.0
gal_theta = np.deg2rad(90.0 - 48.05)
gal_phi = np.deg2rad(264.31)
z = self.solar_speed * np.cos(gal_theta)
x = self.solar_speed * np.sin(gal_theta) * np.cos(gal_phi)
y = self.solar_speed * np.sin(gal_theta) * np.sin(gal_phi)
self.solar_vel = np.array([x, y, z])
self.solar_quat = qa.from_vectors(np.array([0.0, 0.0, 1.0]), self.solar_vel)
self.dip_check = 0.00335673
self.dip_max_pix = hp.ang2pix(self.nside, gal_theta, gal_phi, nest=False)
self.dip_min_pix = hp.ang2pix(self.nside, (np.pi - gal_theta), (np.pi + gal_phi), nest=False)
# Populate the observations
tod = TODHpixSpiral(
self.data.comm.comm_group,
dquat,
self.totsamp,
detranks=self.data.comm.comm_group.size,
firsttime=0.0,
rate=self.rate,
nside=self.nside)
self.data.obs[0]["tod"] = tod
def get_healsparse_subpix_indices(subpix_nside, subpix_hpix, subpix_border, coverage_nside):
"""
Retrieve the coverage pixels that intersect the region, with a border.
Parameters
----------
subpix_nside: `int`
Nside for the subregion
subpix_hpix: `int`
Pixel number for the subregion (ring format)
subpix_border: `float`
Border radius to cover outside subpix_hpix
coverage_nside: `int`
Nside of the healsparse coverage map
"""
# First, we need to know which pixel(s) from nside_coverage are covered by
# subpix_hpix
if subpix_nside == coverage_nside:
# simply convert to nest
covpix = hp.ring2nest(subpix_nside, subpix_hpix)
elif subpix_nside > coverage_nside:
# what pixel is this contained in?
theta, phi = hp.pix2ang(subpix_nside, subpix_hpix, nest=False)
covpix = hp.ang2pix(coverage_nside, theta, phi, nest=True)
else:
# This is subpix_nside < coverage_nside
# what coverage pixels are contained in subpix_hpix?
subpix_hpix_nest = hp.ring2nest(subpix_nside, subpix_hpix)
bit_shift = 2 * int(np.round(np.log(coverage_nside / subpix_nside) / np.log(2)))
n_pix = 2**bit_shift
covpix = np.left_shift(subpix_hpix_nest, bit_shift) + np.arange(n_pix)
# And now if we have a border...
if subpix_border > 0.0:
nside_testing = max([coverage_nside * 4, subpix_nside * 4])
boundaries = hp.boundaries(subpix_nside, subpix_hpix, step=nside_testing/subpix_nside)
extrapix = np.zeros(0, dtype=np.int64)
# These are pixels that touch the boundary
for i in xrange(boundaries.shape[1]):
pixint = hp.query_disc(nside_testing, boundaries[:, i],
np.radians(subpix_border), inclusive=True, fact=8)
extrapix = np.append(extrapix, pixint)
extrapix = np.unique(extrapix)
theta, phi = hp.pix2ang(nside_testing, extrapix)
covpix = np.unique(np.append(covpix, hp.ang2pix(coverage_nside, theta, phi, nest=True)))
return covpix
def is_in(self, ra, decl):
"""
Check if position is in the MOC map.
ra, decl - sky coordinates.
TODO: implement vectorized ra/decl support.
"""
ra = np.atleast_1d(ra)
decl = np.atleast_1d(decl)
theta = 0.5*np.pi - np.radians(decl)
phi = np.radians(ra)
keys = list(self.healpix.keys())
keys.sort()
todo = np.ones(len(ra), dtype=bool)
fullmask = np.arange(len(ra), dtype=int)
for level in keys:
healpix_cell = healpy.ang2pix(2**level, theta[todo], phi[todo],
nest=True)
mask = np.copy(fullmask[todo])
for icell, cell in enumerate(healpix_cell):
if cell in self.healpix[level]:
try:
todo[mask[icell]] = False
except IndexError:
import ipdb; ipdb.set_trace()
return ~todo
def get_src_lthist(self,ra,dec,cth_axis=None):
if cth_axis is None:
cth_axis = copy.deepcopy(self._cth_axis)
new_axis = False
else:
tmp_cth_axis = Axis.create(cth_axis.edges[0],
cth_axis.edges[-1],
cth_axis.nbins*4)
new_axis = True
ipix = healpy.ang2pix(64,np.pi/2. - np.radians(dec),
np.radians(ra),nest=True)
if new_axis:
lt = interpolate(self._cth_axis.center,
self._ltmap[ipix,::-1]/self._cth_axis.width,
tmp_cth_axis.center)*tmp_cth_axis.width
lt = np.sum(lt.reshape(-1,4),axis=1)
else:
lt = self._ltmap[ipix,::-1]
return Histogram(cth_axis,counts=lt,var=0)
def taylor_interpol_iter(m, pos, order=3, verbose=False, lmax=None):
"""Given a healpix map m[npix], and a set of positions
pos[{theta,phi},...], evaluate the values at those positions
using harmonic Taylor interpolation to the given order (3 by
default). Successively yields values for each cumulative order
up to the specified one. If verbose is specified, it will print
progress information to stderr."""
nside = hp.npix2nside(m.size)
if lmax is None: lmax = 3*nside
# Find the healpix pixel centers closest to pos,
# and our deviation from these pixel centers.
ipos = hp.ang2pix(nside, pos[0], pos[1])
pos0 = np.array(hp.pix2ang(nside, ipos))
dpos = pos[:2]-pos0
# Take wrapping into account
bad = dpos[1]>np.pi
dpos[1,bad] = dpos[1,bad]-2*np.pi
bad = dpos[1]<-np.pi
dpos[1,bad] = dpos[1,bad]+2*np.pi
# Since healpix' dphi actually returns dphi/sintheta, we choose
# to expand in terms of dphi*sintheta instead.
dpos[1] *= np.sin(pos0[0])
del pos0
# We will now Taylor expand our healpix field to
# get approximations for the values at our chosen
# locations. The structure of this section is
# somewhat complicated by the fact that alm2map_der1 returns
# two different derivatives at the same time.
derivs = [[m]]
res = m[ipos]
yield res
for o in range(1,order+1):
# Compute our derivatives
derivs2 = [None for i in range(o+1)]
used = [False for i in range(o+1)]
# Loop through previous level in steps of two (except last)
if verbose: tprint("order %d" % o)
for i in range(o):
# Each alm2map_der1 provides two derivatives, so avoid
# doing double work.
if i < o-1 and i % 2 == 1:
continue
a = hp.map2alm(derivs[i], use_weights=True, lmax=lmax, iter=0)
derivs[i] = None
dtheta, dphi = hp.alm2map_der1(a, nside, lmax=lmax)[-2:]
derivs2[i:i+2] = [dtheta,dphi]
del a, dtheta, dphi
# Use these to compute the next level
for j in range(i,min(i+2,o+1)):
if used[j]: continue
N = comb(o,j)/factorial(o)
res += N * derivs2[j][ipos] * dpos[0]**(o-j) * dpos[1]**j
used[j] = True
# If we are at the last order, we don't need to waste memory
# storing the derivatives any more
if o == order: derivs2[j] = None
derivs = derivs2
yield res
def cat2hpx_cg(ra, dec, nside):
"""
def cat2hpx_cg(ra, dec, nside):
R=hp.Rotator(coord='cg')
phi, theta=R(ra, dec, lonlat=True)
theta=90-theta
pixs=hp.ang2pix(nside, theta*nm.pi/180, phi*nm.pi/180, nest=True)
countmap1=nm.zeros((12*nside**2))
for idx in pixs:
countmap1[idx]+=1
return countmap1
"""
R=hp.Rotator(coord='cg')
phi, theta=R(ra, dec, lonlat=True)
theta=90-theta
pixs=hp.ang2pix(nside, theta*nm.pi/180, phi*nm.pi/180, nest=True)
countmap1=nm.zeros((12*nside**2))
for idx in pixs:
countmap1[idx]+=1
return countmap1
def histSpectrum(config):
files = glob.glob('%s/%s_data/files/*.hdf5' % (my.llh_data, config))
files.sort()
nside = 64
npix = hp.nside2npix(nside)
sbins = np.arange(npix, dtype=int)
ebins = np.arange(5, 9.501, 0.05)
for file in files[:10]:
print 'Working on %s...' % file
d = hdf5extractor(config, file)
c0 = d['cuts']['llh']
r = np.log10(d['ML_energy'])[c0]
fit = zfix(d['zenith'], bintype='logdist')[c0]
w = d['weights'][c0]
zen = d['zenith'][c0]
azi = d['azimuth'][c0]
pix = hp.ang2pix(nside, zen, azi)
x = r - fit
y = pix
h0 = np.histogram2d(x, y, bins=(ebins,sbins), weights=w)[0]
def angToPix(nside, lon, lat, nest=False):
"""
Input (lon, lat) in degrees instead of (theta, phi) in radians
"""
theta = np.radians(90. - lat)
phi = np.radians(lon)
return hp.ang2pix(nside, theta, phi, nest=nest)
def zoncaview(m):
"""
m is a healpix sky map, such as provided by WMAP or Planck.
"""
nside = hp.npix2nside(len(m))
vmin = -1e3; vmax = 1e3
# Set up some grids:
xsize = ysize = 1000
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)
grid_map = m[grid_pix]
# Create a sphere:
r = 0.3
x = r*np.sin(THETA)*np.cos(PHI)
y = r*np.sin(THETA)*np.sin(PHI)
z = r*np.cos(THETA)
# The figure:
mlab.figure(1, bgcolor=(1, 1, 1), fgcolor=(0, 0, 0), size=(400, 300))
mlab.clf()
mlab.mesh(x, y, z, scalars=grid_map, colormap="jet", vmin=vmin, vmax=vmax)
mlab.draw()
return
def computeHPXpix_sequ_new_simp(nside, propertyArray):
#return 'ERROR'
#Hack by AJR, just return all of the pixel centers within the ra,dec range
img_ras, img_decs = [propertyArray[v] for v in ['ra0', 'ra1', 'ra2','ra3']],[propertyArray[v] for v in ['dec0', 'dec1', 'dec2','dec3']]
#print min(img_ras),max(img_ras)
#more efficient version below failed for some reason
for i in range(0,len(img_ras)):
if img_ras[i] > 360.:
img_ras[i] -= 360.
if img_ras[i] < 0.:
img_ras[i] += 360.
#if max(img_ras) - min(img_ras) > 1.:
# print img_ras,img_decs
#if np.any(img_ras > 360.0):
# img_ras[img_ras > 360.0] -= 360.0
#if np.any(img_ras < 0.0):
# img_ras[img_ras < 0.0] += 360.0
# Coordinates of image corners
#print img_ras
img_phis = np.multiply(img_ras , np.pi/180.)
img_thetas = np.pi/2. - np.multiply(img_decs , np.pi/180.)
img_pix = hp.ang2pix(nside, img_thetas, img_phis, nest=False)
pix_thetas, pix_phis = hp.pix2ang(nside, img_pix, nest=False)
ipix_list = np.zeros(0, dtype=long)
# loop over rings until reached bottom
iring_U = ring_num(nside, np.cos(img_thetas.min()), shift=0)
iring_B = ring_num(nside, np.cos(img_thetas.max()), shift=0)
ipixs_ring = []
pmax = np.max(img_phis)
pmin = np.min(img_phis)
if pmax-pmin == 0:
return []
p1 = pmin
p2 = pmax
if pmin < .1 and pmax > 1.9*np.pi:
#straddling line
#img_phis.sort()
for i in range(0,len(img_phis)):
if img_phis[i] > p1 and img_phis[i] < np.pi:
p1 = img_phis[i]
if img_phis[i] < p2 and img_phis[i] > np.pi:
p2 = img_phis[i]
#ipixs_ring1 = np.int64(np.concatenate([in_ring(nside, iring, 0, p1, conservative=False) for iring in range(iring_U, iring_B+1)]))
#ipixs_ring2 = np.int64(np.concatenate([in_ring(nside, iring, p2, 2.*np.pi, conservative=False) for iring in range(iring_U, iring_B+1)]))
# ipixs_ring1 = np.int64(np.concatenate([in_ring_simp(nside, iring, 0, p1, conservative=False) for iring in range(iring_U, iring_B+1)]))
# ipixs_ring2 = np.int64(np.concatenate([in_ring_simp(nside, iring, p2, 2.*np.pi, conservative=False) for iring in range(iring_U, iring_B+1)]))
# ipixs_ring = np.concatenate((ipixs_ring1,ipixs_ring2))
# print len(ipixs_ring),len(ipixs_ring1),len(ipixs_ring2),iring_B-iring_U,pmin,pmax,p1,p2
#
# else:
ipixs_ring = np.int64(np.concatenate([in_ring(nside, iring, p1, p2, conservative=False) for iring in range(iring_U, iring_B+1)]))
#ipixs_ring = np.int64(np.concatenate([in_ring_simp(nside, iring, p1, p2, conservative=False) for iring in range(iring_U, iring_B+1)]))
if len(ipixs_ring) > 1000:
print len(ipixs_ring),iring_B-iring_U,pmin,pmax,p1,p2
return [] #temporary fix
# print len(ipixs_ring),iring_B-iring_U,pmin,pmax,min(img_ras),max(img_ras)
#print len(ipixs_ring),iring_B-iring_U,pmin,pmax,min(img_ras),max(img_ras)
return ipixs_ring
def eqmap2azelmap(map,longi=-104.245,lat=34.4717,ut=12.0,year=2014,month=5,day=29):
"""
function to rotate celestial coord map to az el with brute force using tools below from Victor Roytman
"""
julian_date=jdcnv(year,month,day,ut)
obs=ephem.Observer()
obs.lon=str(longi)
obs.lat=str(lat)
obs.date=ephem.date((year,month,day,ut))
nside=np.int(np.sqrt(len(map)/12))
outmap=np.zeros(len(map))
pixlist=range(len(map))
htheta,hphi=hp.pix2ang(nside,pixlist)
elevation=np.pi/2. -htheta
azimuth=hphi
ctheta=[]
cphi=[]
for az,el in zip(azimuth,elevation):
ra,dec=obs.radec_of(az,el)
ctheta.append(np.pi/2. -dec)
cphi.append(ra)
#ra,dec=azel2radec(julian_date, azimuth, elevation, lat*dtr, longi)
#ctheta=np.pi/2.-dec
#cphi=ra
ctheta=np.array(ctheta)
cphi=np.array(cphi)
rpixlist=hp.ang2pix(nside,ctheta,cphi)
outmap[pixlist]=map[rpixlist]
return outmap
def smooth_the_pixel_by_angles(self,angle_vec,counts_vec): #angle vec of the form [ [theta,phi], [theta,phi], ... ] smoothed_pixel_map = np.zeros(self.npix) #theta_center,phi_center = hp.pix2ang(self.nside,pix_num_center) # theta_center=angle_vec[::,0] # phi_center=angle_vec[::,1] for theta_center,phi_center, count in map(None,angle_vec[0],angle_vec[1],counts_vec): #ta = time.time() #theta_center,phi_center = angle lat = theta_center*360/(2*np.pi) lng = phi_center*360/(2*np.pi) mask_where = masks.mask_ring(0, self.mult_sigma_for_smooth*self.sigma*360/(2*np.pi),lat, lng, self.nside) #mask_where=np.ones(self.npix) #print 'start: ', time.time() - ta mask_pixel_vals = np.where(mask_where == 1)[0] pix_num_center=hp.ang2pix(self.nside,theta_center,phi_center) mask_pixel_vals = np.array(list(set(list(mask_pixel_vals) + [pix_num_center]))) #print 'The mask_pixel_vals are ',mask_pixel_vals #t0 = time.time() vals = np.vectorize(self.gaussian_func_ang)(theta_center,phi_center,mask_pixel_vals) #print 'step vals: ', time.time() - t0 #print 'The vals are ', vals #print 'Sum of vals: ', np.sum(vals) if np.sum(vals)==0: smoothed_pixel_map[pix_num_center] += count else: smoothed_pixel_map[mask_pixel_vals] += count*vals/np.sum(vals) #print 'total: ', time.time() - ta return smoothed_pixel_map #normalize to one
def RaDec2Healpix(ra=None, dec=None, nside=None, nest=False, cat=None):
"""
Compute the HEALPix index for each RA/DEC pair. Numpy array is returned.
Parameters
----------
cat (None/structured array)
If not None, the structured data array (e.g. numpy recarray)
ra (float array/str)
if `cat` is None, an array of the RA values. Otherwise, the column name for the RA column in `cat`.
dec (float array/str)
if `cat` is None, an array of the DEC values. Otherwise, the column name for the DEC column in `cat`.
nside (int)
HEALPix nside
nest (bool)
Whether or not to use nested format
Returns
-------
index (int)
Array of the HEALPix indexes for each RA/DEC pair.
"""
_nsideExcept(nside)
r, d = _CatOrArrays(cat, ra, dec)
phi = _np.radians(r)
theta = _np.radians(90.0 - d)
hpInd = _hp.ang2pix(nside, theta, phi, nest=nest)
return hpInd
def mkgalmapY3ac(res,zr,gz='.gz',md='',fore='',wm='',syscut=''): gl = [] for i in range(0,12*res*res): gl.append(0) #f = fitsio.read(dir+'dr1_lss_red_'+zr+'_v0_redux.fits.gz',ext=1) f = fitsio.read(dir+'test'+zr+mask+'.fits'+gz,ext=1) ngt = 0 w = 1. zem = 0 fw = '' if fore == 'fore': fw = '_fore' #if fore == 'auto': # fw = '_auto' if md == 'nodepth': md = '_none' #else: # md = '_'+md for i in range(0,len(f)): ra,dec = f[i]['RA'],f[i]['DEC'] #if f[i]['v0'+md+fw] == 1.: #if wm != '': # w = float(ln[4]) #if z > zmin and z < zmax: th,phi = radec2thphi(ra,dec) p = hp.ang2pix(res,th,phi,nest=True) gl[p] += w ngt += w print len(gl),ngt return gl
def __expand_valid(self, min_p=1e-7):
#
# Determine what the 'quanta' of probabilty is
#
if self._massp == 1.0:
# This is to ensure we don't blow away everything because the map
# is very spread out
min_p = min(min_p, max(self.skymap))
else:
# NOTE: Only valid if CDF descending order is kept
min_p = self.pseudo_pdf(*self.valid_points_decra[-1])
self.valid_points_hist = []
ns = healpy.npix2nside(len(self.skymap))
# Renormalize first so that the vector histogram is properly normalized
self._renorm = 0
# Account for probability lost due to cut off
for i, v in enumerate(self.skymap >= min_p):
self._renorm += self.skymap[i] if v else 0
for pt in self.valid_points_decra:
th, ph = HealPixSampler.decra2thph(pt[0], pt[1])
pix = healpy.ang2pix(ns, th, ph)
if self.skymap[pix] < min_p:
continue
self.valid_points_hist.extend([pt]*int(round(self.pseudo_pdf(*pt)/min_p)))
self.valid_points_hist = numpy.array(self.valid_points_hist).T
def make_counts_maps(ra,dec,z,z_tics,mask):
"""
Make counts maps from ra,dec and z data.
@param ra Right assention of the object in degrees
@param dec Declination of the object in degrees
@param z Redshift of the object
@param z_tics an array of points that define the z-slizes
@param mask The mask to be applied. This should be a vecor or zero or one
entries and it should have the same number of pxiels as the output map.
Returns counts map as a numpy array of dimensions [npix,len(z_tics)-1]
"""
print "\ncreating the counts map"
# sanity checks
if len(ra) != len(dec) : raise RuntimeError("ra and dec have different sizes")
if len(ra) != len(z) : raise RuntimeError("ra and z have different sizes")
if len(z_tics) <2 : raise RuntimeError("at least 2 tics required to define a bin")
nside=0
try:
nside = hp.npix2nside(np.shape(mask)[0])
except:
raise RuntimeError("length of mask not a healpix npix")
# define the maps
nmaps = len(z_tics)-1
npix = np.shape(mask)[0]
counts = np.zeros([npix,nmaps])
# go through each object and add them into the correct bins
for i in range(len(ra)):
# convert (ra,dec) to (theta,phi)
theta=-degr2rad*dec[i] + np.pi/2.
phi=degr2rad*ra[i]
# find the pixel id
try:
pixid=hp.ang2pix(nside,theta,phi)
except:
print "wrong theta and phi: theta= ",theta,"phi= ",phi,"ra= ",ra[i],"dec= ",dec[i]
#raise RuntimeError("wrong theta and phi")
# is the pixel in the mask?
if mask[pixid]>0 :
# find the bin to which the current object belong to
binid=np.searchsorted(z_tics,z[i])-1
# is the bind in the range?
if binid >=0 and binid < len(z_tics)-1:
try:
counts[pixid,binid] += 1
except:
print "index error binid= ",binid,"len(z_tics)= ",len(z_tics),"z[i]= ",z[i]
# return the maps
return counts
def generate_map(t, p, nside, plot=False):
"""Generate map and bands for the given galaxy locations"""
npix = 12*nside**2
ix = hp.ang2pix(nside, t, p, nest=True)
M = np.zeros(npix)
for i in xrange(len(ix)):
M[ix[i]] += 1.
ave = 1.*len(t)/npix
M = M/ave-1.0 #Calculate overdensity
cl = hp.anafast(M)
ell = np.arange(len(cl))+1
ell2 = (ell[::3]+ell[1::3]+ell[2::3])/3.
cl2 = (cl[::3]+cl[1::3]+cl[2::3])/3.
if plot:
plot_galaxies_and_density(t, p, M)
plot_anafast_band_powers(ell2, cl2)
plt.show()
ell3 = ell2[1:]
cl3 = cl2[1:] #Alex to Matias: Why are these removed?
cl_err = np.ones(len(ell3))*0.00002
index = np.arange(len(ell3))
ell_min = ell3-1
ell_max = ell3+1
cl3 = cl3*1000 #Bigger c_l values for convergence
bands = zip(index, ell3, ell_min, ell_max, cl3, cl_err, cl3)
return M, bands
def get_mask_gal(percentage_keep=40, nside_out=512, coordinates='eq', quick=True):
import pyfits
from astropy.coordinates import FK5
from astropy import units as u
savename = datadir+'mask_GAL0%i_%i_'%(percentage_keep,nside_out)
savename += coordinates+'_.pkl'
if quick: return pickle.load(open(savename,'r'))
pp = pyfits.open(datadir+'HFI_Mask_GalPlane_2048_R1.10.fits')
mask_gal = pp[1].data['GAL0%i'%percentage_keep]
mask_gal = hp.reorder(mask_gal, out='RING', inp='NESTED')
if coordinates=='gal':
mask_out = hp.ud_grade(mask_gal, nside_out)
if coordinates=='eq':
nside_up = nside_out*2
mask_gal = hp.ud_grade(mask_gal, nside_up)
# Find the indices in an up-sampled *galactic* map that belong to these
# *equatorial* coordinates.
theta, phi = hp.pix2ang(nside_up, np.arange(hp.nside2npix(nside_up)))
ra = phi
dec = np.pi/2.-theta
coord = FK5(ra=ra, dec=dec, unit=(u.rad, u.rad))
l_gal = coord.galactic.l.rad
b_gal = coord.galactic.b.rad
phi = l_gal
theta = np.pi/2.-b_gal
ind_up = hp.ang2pix(nside_up, theta, phi)
mask_up_eq = mask_gal[ind_up]
mask_out = hp.ud_grade(mask_up_eq, nside_out)
pickle.dump(mask_out, open(savename,'w'))
return mask_out
def pseudo_pdf(self, dec_in, ra_in):
"""
Return pixel probability for a given dec_in and ra_in. Note, uses healpy functions to identify correct pixel.
"""
th, ph = HealPixSampler.decra2thph(dec_in, ra_in)
res = healpy.npix2nside(len(self.skymap))
return self.skymap[healpy.ang2pix(res, th, ph)]
def get_haslam(nside_out=512, coordinates='eq', quick=True):
savename = datadir+'haslam_'+coordinates+'_%i.pkl'%nside_out
if quick: return pickle.load(open(savename,'r'))
radio = hp.read_map(datadir+'lambda_haslam408_dsds.fits')
if coordinates=='gal':
radio_out = hp.ud_grade(radio, nside_out)
if coordinates=='eq':
from astropy.coordinates import FK5
from astropy import units as u
# Up-sample and convert from galactic to equatorial.
nside_up = nside_out*2
radio_up_gal = hp.ud_grade(radio, nside_up)
# Find the indices in an up-sampled *galactic* map that belong to these
# *equatorial* coordinates.
theta, phi = hp.pix2ang(nside_up, np.arange(hp.nside2npix(nside_up)))
ra = phi
dec = np.pi/2.-theta
coord = FK5(ra=ra, dec=dec, unit=(u.rad, u.rad))
l_gal = coord.galactic.l.rad
b_gal = coord.galactic.b.rad
phi = l_gal
theta = np.pi/2.-b_gal
ind_up = hp.ang2pix(nside_up, theta, phi)
radio_up_eq = radio_up_gal[ind_up]
radio_out = hp.ud_grade(radio_up_eq, nside_out)
mask_out = np.ones_like(radio_out)
pickle.dump((radio_out, mask_out), open(savename,'w'))
return radio_out, mask_out
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 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 __init__(self,
ras_deg=None,
decs_deg=None,
shape=None,
wcs=None,
nside=None,
verbose=True,
hp_coords="equatorial",
mask=None,
weights=None,
pixs=None):
self.verbose = verbose
if nside is not None:
self.nside = nside
self.shape = hp.nside2npix(nside)
self.curved = True
else:
self.shape = shape
self.wcs = wcs
self.curved = False
if pixs is None:
if nside is not None:
eq_coords = ['fk5', 'j2000', 'equatorial']
gal_coords = ['galactic']
if verbose: print("Calculating pixels...")
if hp_coords in gal_coords:
if verbose: print("Transforming coords...")
from astropy.coordinates import SkyCoord
import astropy.units as u
gc = SkyCoord(ra=ras_deg * u.degree,
dec=decs_deg * u.degree,
frame='fk5')
gc = gc.transform_to('galactic')
phOut = gc.l.deg * np.pi / 180.
thOut = gc.b.deg * np.pi / 180.
thOut = np.pi / 2. - thOut #polar angle is 0 at north pole
self.pixs = hp.ang2pix(nside, thOut, phOut)
elif hp_coords in eq_coords:
ras_out = ras_deg
decs_out = decs_deg
self.pixs = hp.ang2pix(nside,
ras_out,
decs_out,
lonlat=True)
else:
raise ValueError
if verbose: print("Done with pixels...")
else:
coords = np.vstack((decs_deg, ras_deg)) * np.pi / 180.
if verbose: print("Calculating pixels...")
self.pixs = enmap.sky2pix(shape, wcs, coords,
corner=True) # should corner=True?!
if verbose: print("Done with pixels...")
else:
self.pixs = pixs
self.counts = self.get_map(weights=weights)
if weights is None:
self.rcounts = self.get_map(weights=None)
else:
self.rcounts = self.counts
if not self.curved:
self.counts = enmap.enmap(self.counts, self.wcs)
self.mask = np.ones(shape) if mask is None else mask
self._counts()
def main(arguments=None):
"""
*The main function used when ``find_atlas_exposure_containing_ssobject.py`` is run as a single script from the cl*
"""
# SETUP VARIABLES
# MAKE SURE HEALPIX SMALL ENOUGH TO MATCH FOOTPRINTS CORRECTLY
nside = 1024
pi = (4 * math.atan(1.0))
DEG_TO_RAD_FACTOR = pi / 180.0
RAD_TO_DEG_FACTOR = 180.0 / pi
tileSide = 5.46
i = 0
outputList = []
rsyncContent = []
obscodes = {"02": "T05", "01": "T08"}
# SETUP THE COMMAND-LINE UTIL SETTINGS
su = tools(arguments=arguments,
docString=__doc__,
logLevel="WARNING",
options_first=False,
projectName=False)
arguments, settings, log, dbConn = su.setup()
# UNPACK REMAINING CL ARGUMENTS USING `EXEC` TO SETUP THE VARIABLE NAMES
# AUTOMATICALLY
for arg, val in arguments.iteritems():
if arg[0] == "-":
varname = arg.replace("-", "") + "Flag"
else:
varname = arg.replace("<", "").replace(">", "")
if isinstance(val, str) or isinstance(val, unicode):
exec(varname + " = '%s'" % (val, ))
else:
exec(varname + " = %s" % (val, ))
if arg == "--dbConn":
dbConn = val
log.debug('%s = %s' % (
varname,
val,
))
dbSettings = {
'host': '127.0.0.1',
'user': '******',
'tunnel': {
'remote ip': 'starbase.mp.qub.ac.uk',
'remote datbase host': 'dormammu',
'remote user': '******',
'port': 5003
},
'password': '******',
'db': 'atlas_moving_objects'
}
# SETUP DATABASE CONNECTIONS
dbConn = database(log=log, dbSettings=dbSettings).connect()
# GRAB THE EXPOSURE LISTING
for expPrefix, obscode in obscodes.iteritems():
exposureList = []
mjds = []
sqlQuery = "select * from atlas_exposures where expname like '%(expPrefix)s%%'" % locals(
)
connected = 0
while connected == 0:
try:
rows = readquery(log=log,
sqlQuery=sqlQuery,
dbConn=dbConn,
quiet=False)
connected = 1
except:
# SETUP DATABASE CONNECTIONS
dbConn = database(log=log, dbSettings=dbSettings).connect()
print "Can't connect to DB - try again"
time.sleep(2)
t = len(rows)
print "There are %(t)s '%(expPrefix)s' exposures to check - hang tight" % locals(
)
for row in rows:
row["mjd"] = row["mjd"] + row["exp_time"] / (2. * 60 * 60 * 24)
exposureList.append(row)
mjds.append(row["mjd"])
results = []
batchSize = 500
total = len(mjds[1:])
batches = int(total / batchSize)
start = 0
end = 0
theseBatches = []
for i in range(batches + 1):
end = end + batchSize
start = i * batchSize
thisBatch = mjds[start:end]
theseBatches.append(thisBatch)
i = 0
totalLen = len(theseBatches)
index = 0
for batch in theseBatches:
i += 1
if index > 1:
# Cursor up one line and clear line
sys.stdout.write("\x1b[1A\x1b[2K")
print "Requesting batch %(i)04d/%(totalLen)s from JPL" % locals()
index += 1
eph = jpl_horizons_ephemeris(log=log,
objectId=[ssobject],
mjd=batch,
obscode=obscode,
verbose=False)
for b in batch:
match = 0
# print b
for row in eph:
if math.floor(row["mjd"] * 10000 +
0.01) == math.floor(b * 10000 + 0.01):
match = 1
results.append(row)
if match == 0:
for row in eph:
if math.floor(row["mjd"] * 10000) == math.floor(b *
10000):
match = 1
results.append(row)
if match == 0:
results.append(None)
this = math.floor(b * 10000 + 0.01)
print "MJD %(b)s (%(this)s) is missing" % locals()
for row in eph:
print math.floor(row["mjd"] * 10000 + 0.00001)
print ""
print "Finding the exopsures containing the SS object"
for e, r in zip(exposureList, results):
# CALCULATE SEPARATION IN ARCSEC
if not r:
continue
calculator = separations(
log=log,
ra1=r["ra_deg"],
dec1=r["dec_deg"],
ra2=e["raDeg"],
dec2=e["decDeg"],
)
angularSeparation, north, east = calculator.get()
sep = float(angularSeparation) / 3600.
if sep < 5.:
# THE SKY-LOCATION AS A HEALPIXEL ID
pinpoint = hp.ang2pix(nside,
theta=r["ra_deg"],
phi=r["dec_deg"],
lonlat=True)
decCorners = (e["decDeg"] - tileSide / 2,
e["decDeg"] + tileSide / 2)
corners = []
for d in decCorners:
if d > 90.:
d = 180. - d
elif d < -90.:
d = -180 - d
raCorners = (
e["raDeg"] -
(tileSide / 2) / np.cos(d * DEG_TO_RAD_FACTOR),
e["raDeg"] +
(tileSide / 2) / np.cos(d * DEG_TO_RAD_FACTOR))
for rc in raCorners:
if rc > 360.:
rc = 720. - rc
elif rc < 0.:
rc = 360. + rc
corners.append(hp.ang2vec(rc, d, lonlat=True))
# NEAR THE POLES RETURN SQUARE INTO TRIANGE - ALMOST DEGENERATE
pole = False
for d in decCorners:
if d > 87.0 or d < -87.0:
pole = True
if pole == True:
corners = corners[1:]
else:
# FLIP CORNERS 3 & 4 SO HEALPY UNDERSTANDS POLYGON SHAPE
corners = [corners[0], corners[1], corners[3], corners[2]]
# RETURN HEALPIXELS IN EXPOSURE AREA
expPixels = hp.query_polygon(nside, np.array(corners))
if pinpoint in expPixels:
outputList.append({
"obs": e["expname"],
"mjd": e["mjd"],
"raDeg": r["ra_deg"],
"decDeg": r["dec_deg"],
"mag": r["apparent_mag"],
"sep": sep
})
thisMjd = int(math.floor(e["mjd"]))
expname = e["expname"]
ssobject_ = ssobject.replace(" ", "_")
raStr = r["ra_deg"]
decStr = r["dec_deg"]
rsyncContent.append(
"rsync -av [email protected]:/atlas/red/%(expPrefix)sa/%(thisMjd)s/%(expname)s.fits.fz %(ssobject_)s_atlas_exposures/"
% locals())
rsyncContent.append(
"touch %(ssobject_)s_atlas_exposures/%(expname)s.location"
% locals())
rsyncContent.append(
'echo "_RAJ2000,_DEJ2000,OBJECT\n%(raStr)s,%(decStr)s,%(ssobject)s" > %(ssobject_)s_atlas_exposures/%(expname)s.location'
% locals())
dataSet = list_of_dictionaries(
log=log,
listOfDictionaries=outputList,
# use re.compile('^[0-9]{4}-[0-9]{2}-[0-9]{2}T') for mysql
reDatetime=False)
ssobject = ssobject.replace(" ", "_")
csvData = dataSet.csv(
filepath="./%(ssobject)s_atlas_exposure_matches.csv" % locals())
rsyncContent = ("\n").join(rsyncContent)
pathToWriteFile = "./%(ssobject)s_atlas_exposure_rsync.sh" % locals()
try:
log.debug("attempting to open the file %s" % (pathToWriteFile, ))
writeFile = codecs.open(pathToWriteFile, encoding='utf-8', mode='w')
except IOError, e:
message = 'could not open the file %s' % (pathToWriteFile, )
log.critical(message)
raise IOError(message)
def get_data(data_location='./',
data_type=None,
longitude_range=(0, 360),
latitude_range=(-90, 90),
field=0,
resolution=0.1,
cut_last_pixel=False,
verbose=True,
return_header=True,
reverse_xaxis=True,
dr_version=1):
''' Extracts region from Planck data set. Region will be in galactic
coordinates.
Parameters
----------
data_location : str
Filepath to location of Planck data. Default is current directory.
data_type : str
Data type to choose from. Options are:
Narrow-band: ['CO-Type1', 'CO-Type2', 'CO-Type3']
'CO-Type1' fields:
0: 12CO J 1-->0 Intensity
1: 12CO J 1-->0 Intensity Error
2: 12CO J 1-->0 Null Test
3: 12CO J 1-->0 Mask
4: 12CO J 2-->1 Intensity
5: 12CO J 2-->1 Intensity Error
6: 12CO J 2-->1 Null Test
7: 12CO J 2-->1 Mask
8: 12CO J 3-->2 Intensity
9: 12CO J 3-->2 Intensity Error
10: 12CO J 3-->2 Null Test
11: 12CO J 3-->2 Mask
'CO-Type2' fields:
0: 12CO J 1-->0 Intensity
1: 12CO J 1-->0 Intensity Error
2: 12CO J 1-->0 Null Test
3: 12CO J 1-->0 Mask
4: 12CO J 2-->1 Intensity
5: 12CO J 2-->1 Intensity Error
6: 12CO J 2-->1 Null Test
7: 12CO J 2-->1 Mask
'CO-Type3' fields:
0: 12CO Intensity
1: 12CO Intensity Error
2: 12CO Null Test
3: 12CO Mask
Broad-band (GHz): ['030', '044', '070', '100', '143', '217', '353',
'545', '857']
Broad-band fields:
0: I stokes
1: Hits
2: II_cov
Processed data products: ['Dust Opacity', 'Thermal']
'Dust Opacity' fields:
0: Opacity 353GHz
1: Error on opacity
2: E(B-V)
3: Error on E(B-V)
4: T for high freq correction
5: Error on T
6: Beta for high freq correction
7: Error on Beta
'Thermal' dust model fields:
0: Intensity
1: Intensity standard deviation
2: Intensity ??
3: Intensity ??
longitude : array-like
Lower and upper longitude. Default is whole sky.
latitude : array-like
Lower and upper latitude. Default is whole sky.
field : int
Field in data type.
resolution : float
Pixel resolution in arcseconds.
cut_last_pixel : bool
Cuts off one pixel
return_header : bool
Return the header?
verbose : bool
Verbose?
reverse_xaxis : bool
The highest x-axis value begins at the origin.
dr_version : int
Data release version of data.
Returns
-------
map : array-like
Map of extracted region from Planck data.
header : dict, optional
FITS format header.
Examples
--------
>>> import planckpy as pl
>>> import pyfits as pf
>>> (data, header) = pl.get_data(data_type = '857', longitude_range =
(155,165), latitude_range = (-30, -15))
>>> data.shape
(151, 101)
>>> header['TYPE']
'I_STOKES'
>>> pf.writeto('planck_region_857GHz.fits', data, header = header)
'''
if data_type is None:
print('WARNING (get_data): No data type chosen. Returning None type.')
return None
# Get the filename
filename = get_planck_filename(data_type=data_type,
data_location=data_location,
dr_version=dr_version)
if verbose:
print('Reading file:\n%s' % (filename))
# Read the map using healpy library
map_data = healpy.read_map(filename, field=field, h=True)
map_raw, header_raw = map_data[0], map_data[1]
# Change format of healpy header to pyfits header
# ...an actually useful format
header_pf = pf.Header()
for item in header_raw:
header_pf.append(item)
# Get nside from HEALPix format, acts as resolution of HEALPix image
nside = header_pf['NSIDE']
# Set up longitude / latitude grid for extracting the region
longitude_res, latitude_res = resolution, resolution
pixel_count_long = (longitude_range[1] - longitude_range[0]) / \
longitude_res + 1
pixel_count_lat = (latitude_range[1] - latitude_range[0]) / \
latitude_res + 1
if cut_last_pixel:
pixel_count_long -= 1
pixel_count_lat -= 1
# Write axes of l/b positions
longitude_axis = longitude_range[0] + longitude_res * \
np.arange(pixel_count_long)
latitude_axis = latitude_range[0] + latitude_res * \
np.arange(pixel_count_lat)
# Create map of l/b positions
longitude_grid = np.zeros(shape=(pixel_count_long, pixel_count_lat))
latitude_grid = np.zeros(shape=(pixel_count_long, pixel_count_lat))
for b in range(len(latitude_axis)):
longitude_grid[:, b] = longitude_axis
for l in range(len(longitude_axis)):
latitude_grid[l, :] = latitude_axis
# Convert from phi / theta to l/b
phi_grid = longitude_grid / 180. * np.pi
theta_grid = (90. - latitude_grid) / 180. * np.pi
# Convert from angle to pixel
pixel_indices = healpy.ang2pix(
nside=nside,
theta=theta_grid,
phi=phi_grid,
)
# Map the column data to a 2d array
map_region = map_raw[pixel_indices]
# Omit the degenerate axes
map_region = np.squeeze(map_region)
# Reverse the array
if reverse_xaxis:
map_region = map_region.T[::, ::-1]
elif not reverse_xaxis:
map_region = map_region.T
# Build a header
if return_header:
header_region = build_header(header=header_pf,
axes=(longitude_axis, latitude_axis),
reverse_xaxis=reverse_xaxis,
field=field)
return map_region, header_region
else:
return map_region
def inject_scan(self, ra, dec, ns, poisson=True):
r''' Run All sky scan using event localization as
spatial prior, while also injecting events according
to event localization
Parameters:
-----------
ns: float
Number of signal events to inject
poisson: bool
Will poisson fluctuate number of signal events
to be injected
Returns:
--------
ts: array
array of ts values of
'''
### Set up spatial prior to be used in scan
spatial_prior = SpatialPrior(self.skymap,
allow_neg=self._allow_neg,
containment=self._containment)
pixels = np.arange(len(self.skymap))
## Perform all sky scan
inj = PointSourceInjector(gamma=2, E0=1000.)
inj.fill(dec,
self.llh.exp,
self.llh.mc,
self.llh.livetime,
temporal_model=self.llh.temporal_model)
ni, sample = inj.sample(ra, ns, poisson=poisson)
print('injected neutrino at:')
print(np.rad2deg(sample['ra']), np.rad2deg(sample['dec']))
val = self.llh.scan(0.0,
0.0,
scramble=False,
spatial_prior=spatial_prior,
time_mask=[self.duration / 2., self.centertime],
pixel_scan=[self.nside, self._pixel_scan_nsigma],
inject=sample)
exp = self.llh.inject_events(self.llh.exp, sample)
exp_theta = 0.5 * np.pi - exp['dec']
exp_phi = exp['ra']
exp_pix = hp.ang2pix(self.nside, exp_theta, exp_phi)
overlap = np.isin(exp_pix, self.ipix_90)
t_mask = (exp['time'] <= self.stop) & (exp['time'] >= self.start)
events = exp[t_mask]
# add field to see if neutrino is within 90% GW contour
events = append_fields(events,
names=['in_contour', 'ts', 'ns', 'gamma', 'B'],
data=np.empty((5, events['ra'].size)),
usemask=False)
for i in range(events['ra'].size):
events['in_contour'][i] = overlap[i]
for i in range(events['ra'].size):
events['B'][i] = self.llh.llh_model.background(events[i])
if val['TS'].size == 0:
return (0, 0, 2.0, None)
else:
ts = val['TS_spatial_prior_0'].max()
maxLoc = np.argmax(val['TS_spatial_prior_0'])
ns = val['nsignal'][maxLoc]
gamma = val['gamma'][maxLoc]
ra = val['ra'][maxLoc]
dec = val['dec'][maxLoc]
val_pix = hp.ang2pix(self.nside, np.pi / 2. - val['dec'], val['ra'])
for i in range(events['ra'].size):
idx, = np.where(val_pix == exp_pix[t_mask][i])
events['ts'][i] = val['TS_spatial_prior_0'][idx[0]]
events['ns'][i] = val['nsignal'][idx[0]]
events['gamma'][i] = val['gamma'][idx[0]]
results = dict([('ts', ts), ('ns', ns), ('gamma', gamma), ('ra', ra),
('dec', dec)])
return (results, events)
def _healpix_lookup(map, lon, lat):
"""Look up the value of a HEALPix map in the pixel containing the point
with the specified longitude and latitude."""
nside = hp.npix2nside(len(map))
return map[hp.ang2pix(nside, 0.5 * np.pi - lat, lon)]
def healpix_to_image(healpix_data,
coord_system_in,
wcs_out,
shape_out,
order='bilinear',
nested=False):
"""
Convert image in HEALPIX format to a normal FITS projection image (e.g.
CAR or AIT).
.. note:: This function uses healpy, which is licensed
under the GPLv2, so any package using this funtions has to (for
now) abide with the GPLv2 rather than the BSD license.
Parameters
----------
healpix_data : `numpy.ndarray`
HEALPIX data array
coord_system_in : str or `~astropy.coordinates.BaseCoordinateFrame`
The coordinate system for the input HEALPIX data, as an Astropy
coordinate frame or corresponding string alias (e.g. ``'icrs'`` or
``'galactic'``)
wcs_out : `~astropy.wcs.WCS`
The WCS of the output array
shape_out : tuple
The shape of the output array
order : int or str, optional
The order of the interpolation (if ``mode`` is set to
``'interpolation'``). This can be either one of the following strings:
* 'nearest-neighbor'
* 'bilinear'
or an integer. A value of ``0`` indicates nearest neighbor
interpolation.
nested : bool
The order of the healpix_data, either nested or ring. Stored in
FITS headers in the ORDERING keyword.
Returns
-------
reprojected_data : `numpy.ndarray`
HEALPIX image resampled onto the reference image
footprint : `~numpy.ndarray`
Footprint of the input array in the output array. Values of 0 indicate
no coverage or valid values in the input image, while values of 1
indicate valid values.
"""
import healpy as hp
healpix_data = np.asarray(healpix_data, dtype=float)
# Look up lon, lat of pixels in reference system
yinds, xinds = np.indices(shape_out)
lon_out, lat_out = wcs_out.wcs_pix2world(xinds, yinds, 0)
# Convert between celestial coordinates
coord_system_in = parse_coord_system(coord_system_in)
with np.errstate(invalid='ignore'):
lon_in, lat_in = convert_world_coordinates(
lon_out, lat_out, wcs_out, (coord_system_in, u.deg, u.deg))
# Convert from lon, lat in degrees to colatitude theta, longitude phi,
# in radians
theta = np.radians(90. - lat_in)
phi = np.radians(lon_in)
# hp.ang2pix() raises an exception for invalid values of theta, so only
# process values for which WCS projection gives non-nan value
good = np.isfinite(theta)
data = np.empty(theta.shape, healpix_data.dtype)
data[~good] = np.nan
if isinstance(order, six.string_types):
order = ORDER[order]
if order == 1:
data[good] = hp.get_interp_val(healpix_data, theta[good], phi[good],
nested)
elif order == 0:
npix = len(healpix_data)
nside = hp.npix2nside(npix)
ipix = hp.ang2pix(nside, theta[good], phi[good], nested)
data[good] = healpix_data[ipix]
else:
raise ValueError(
"Only nearest-neighbor and bilinear interpolation are supported")
footprint = good.astype(int)
return data, footprint
def plot_sky_binned(ra,
dec,
weights=None,
data=None,
plot_type='grid',
max_bin_area=5,
clip_lo=None,
clip_hi=None,
verbose=False,
cmap='viridis',
colorbar=True,
label=None,
basemap=None):
"""Show objects on the sky using a binned plot.
Bin values either show object counts per unit sky area or, if an array
of associated data values is provided, mean data values within each bin.
Objects can have associated weights.
Requires that matplotlib and basemap are installed. When plot_type is
"healpix", healpy must also be installed.
Parameters
----------
ra : array
Array of object RA values in degrees. Must have the same shape as
dec and will be flattened if necessary.
dec : array
Array of object DEC values in degrees. Must have the same shape as
ra and will be flattened if necessary.
weights : array or None
Optional of weights associated with each object. All objects are
assumed to have equal weight when this is None.
data : array or None
Optional array of scalar values associated with each object. The
resulting plot shows the mean data value per bin when data is
specified. Otherwise, the plot shows counts per unit sky area.
plot_type : str
Must be either 'grid' or 'healpix', and selects whether data in
binned in healpix or in (sin(DEC), RA).
max_bin_area : float
The bin size will be chosen automatically to be as close as
possible to this value but not exceeding it.
clip_lo : float or str
Clipping is applied to the plot data calculated as counts / area
or the mean data value per bin. See :func:`prepare_data` for
details.
clip_hi : float or str
Clipping is applied to the plot data calculated as counts / area
or the mean data value per bin. See :func:`prepare_data` for
details.
verbose : bool
Print information about the automatic bin size calculation.
cmap : colormap name or object
Matplotlib colormap to use for mapping data values to colors.
colorbar : bool
Draw a colorbar below the map when True.
label : str or None
Label to display under the colorbar. Ignored unless colorbar is True.
basemap : Basemap object or None
Use the specified basemap or create a default basemap using
:func:`init_sky` when None.
Returns
-------
basemap
The basemap used for the plot, which will match the input basemap
provided, or be a newly created basemap if None was provided.
"""
ra = np.asarray(ra).reshape(-1)
dec = np.asarray(dec).reshape(-1)
if len(ra) != len(dec):
raise ValueError('Arrays ra,dec must have same size.')
plot_types = (
'grid',
'healpix',
)
if plot_type not in plot_types:
raise ValueError('Invalid plot_type, should be one of {0}.'.format(
', '.join(plot_types)))
if data is not None and weights is None:
weights = np.ones_like(data)
if plot_type == 'grid':
# Convert the maximum pixel area to steradians.
max_bin_area = max_bin_area * (np.pi / 180.)**2
# Pick the number of bins in cos(DEC) and RA to use.
n_cos_dec = int(np.ceil(2 / np.sqrt(max_bin_area)))
n_ra = int(np.ceil(4 * np.pi / max_bin_area / n_cos_dec))
# Calculate the actual pixel area in sq. degrees.
bin_area = 360**2 / np.pi / (n_cos_dec * n_ra)
if verbose:
print(
'Using {0} x {1} grid in cos(DEC) x RA'.format(
n_cos_dec, n_ra),
'with pixel area {:.3f} sq.deg.'.format(bin_area))
# Calculate the bin edges in degrees.
ra_edges = np.linspace(-180., +180., n_ra + 1)
dec_edges = np.degrees(np.arcsin(np.linspace(-1., +1., n_cos_dec + 1)))
# Put RA values in the range [-180, 180).
ra = np.fmod(ra, 360.)
ra[ra >= 180.] -= 360.
# Histogram the input coordinates.
counts, _, _ = np.histogram2d(dec,
ra, [dec_edges, ra_edges],
weights=weights)
if data is None:
grid_data = counts / bin_area
else:
sums, _, _ = np.histogram2d(dec,
ra, [dec_edges, ra_edges],
weights=weights * data)
# This ratio might result in some nan (0/0) or inf (1/0) values,
# but these will be masked by prepare_data().
settings = np.seterr(all='ignore')
grid_data = sums / counts
np.seterr(**settings)
grid_data = prepare_data(grid_data, clip_lo=clip_lo, clip_hi=clip_hi)
basemap = plot_grid_map(grid_data, ra_edges, dec_edges, cmap, colorbar,
label, basemap)
elif plot_type == 'healpix':
import healpy as hp
for n in range(1, 25):
nside = 2**n
bin_area = hp.nside2pixarea(nside, degrees=True)
if bin_area <= max_bin_area:
break
npix = hp.nside2npix(nside)
nest = False
if verbose:
print('Using healpix map with NSIDE={0}'.format(nside),
'and pixel area {:.3f} sq.deg.'.format(bin_area))
pixels = hp.ang2pix(nside, np.radians(90 - dec), np.radians(ra), nest)
counts = np.bincount(pixels, weights=weights, minlength=npix)
if data is None:
grid_data = counts / bin_area
else:
sums = np.bincount(pixels, weights=weights * data, minlength=npix)
grid_data = np.zeros_like(sums, dtype=float)
nonzero = counts > 0
grid_data[nonzero] = sums[nonzero] / counts[nonzero]
grid_data = prepare_data(grid_data, clip_lo=clip_lo, clip_hi=clip_hi)
basemap = plot_healpix_map(grid_data, nest, cmap, colorbar, label,
basemap)
return basemap
def plot_healpix_map(data,
nest=False,
cmap='viridis',
colorbar=True,
label=None,
basemap=None,
vlimits=None):
"""Plot a healpix map using an all-sky projection.
Pass the data array through :func:`prepare_data` to select a subset to plot
and clip the color map to specified values or percentiles.
This function is similar to :func:`plot_grid_map` but is generally slower
at high resolution and has less elegant handling of pixels that wrap around
in RA, which are not drawn.
Requires that matplotlib, basemap, and healpy are installed.
Parameters
----------
data : array or masked array
1D array of data associated with each healpix. Must have a size that
exactly matches the number of pixels for some NSIDE value. Use the
output of :func:`prepare_data` as a convenient way to specify
data cuts and color map clipping.
nest : bool
If True, assume NESTED pixel ordering. Otheriwse, assume RING pixel
ordering.
cmap : colormap name or object
Matplotlib colormap to use for mapping data values to colors.
colorbar : bool
Draw a colorbar below the map when True.
label : str or None
Label to display under the colorbar. Ignored unless colorbar is True.
basemap : Basemap object or None
Use the specified basemap or create a default basemap using
:func:`init_sky` when None.
Returns
-------
basemap
The basemap used for the plot, which will match the input basemap
provided, or be a newly created basemap if None was provided.
"""
import healpy as hp
import matplotlib.pyplot as plt
import matplotlib.colors
from matplotlib.collections import PolyCollection
data = prepare_data(data)
if len(data.shape) != 1:
raise ValueError('Invalid data array, should be 1D.')
nside = hp.npix2nside(len(data))
if basemap is None:
basemap = init_sky()
# Get pixel boundaries as quadrilaterals.
corners = hp.boundaries(nside, np.arange(len(data)), step=1, nest=nest)
corner_theta, corner_phi = hp.vec2ang(corners.transpose(0, 2, 1))
corner_ra, corner_dec = (np.degrees(corner_phi),
np.degrees(np.pi / 2 - corner_theta))
# Convert sky coords to map coords.
x, y = basemap(corner_ra, corner_dec)
# Regroup into pixel corners.
verts = np.array([x.reshape(-1, 4), y.reshape(-1, 4)]).transpose(1, 2, 0)
# Find and mask any pixels that wrap around in RA.
uv_verts = np.array(
[corner_phi.reshape(-1, 4),
corner_theta.reshape(-1, 4)]).transpose(1, 2, 0)
theta_edge = np.unique(uv_verts[:, :, 1])
phi_edge = np.radians(basemap.lonmax)
eps = 0.1 * np.sqrt(hp.nside2pixarea(nside))
wrapped1 = hp.ang2pix(nside, theta_edge, phi_edge - eps, nest=nest)
wrapped2 = hp.ang2pix(nside, theta_edge, phi_edge + eps, nest=nest)
wrapped = np.unique(np.hstack((wrapped1, wrapped2)))
data.mask[wrapped] = True
# Normalize the data using its vmin, vmax attributes, if present.
try:
if vlimits is None:
norm = matplotlib.colors.Normalize(vmin=data.vmin, vmax=data.vmax)
else:
norm = matplotlib.colors.Normalize(vmin=vlimits[0],
vmax=vlimits[1])
except AttributeError:
norm = None
# Make the collection and add it to the plot.
collection = PolyCollection(verts,
array=data,
cmap=cmap,
norm=norm,
edgecolors='none')
axes = plt.gca() if basemap.ax is None else basemap.ax
axes.add_collection(collection)
axes.autoscale_view()
if colorbar:
bar = plt.colorbar(collection,
ax=basemap.ax,
orientation='horizontal',
spacing='proportional',
pad=0.01,
aspect=50)
if label:
bar.set_label(label)
return basemap
truemap = h.alm2map(almtrue, nside, lmax=lmax)
truemap *= strength / max(truemap)
print "========="
print "Dipole %d" % dipole
maxi, maxang, mini, minang = GetMaxMin(truemap)
D[0, dipole] = 90. - maxang[0] / degree
# Strength for RA average subtracted
# Loop over possible detector latitudes
for id1, d1 in enumerate(d1s):
for id2, d2 in enumerate(d2s):
print np.pi / 2. - d2 * degree
print np.pi / 2. - d1 * degree
pixLo = h.ang2pix(nside, np.pi / 2. - d2 * degree, 0.)
pixHi = h.ang2pix(nside, np.pi / 2. - d1 * degree, 0.)
out = h.anafast(truemap, alm=True, lmax=lmax)
for i in range(0, lmax + 1):
index = h.sphtfunc.Alm.getidx(lmax, i, 0)
out[1][index] = 0.0
reducedmap = h.alm2map(out[1], nside, lmax=lmax)
reducedmap[0:pixLo] = 0.
reducedmap[pixHi:npix] = 0.
fovPix = pixHi - pixLo
# 'Fit' the dipole
almreducedfit = h.map2alm(reducedmap, lmax=1)
reducedfitmap = h.alm2map(almreducedfit, nside, lmax=1)
maxi, maxang, mini, minang = GetMaxMin(reducedfitmap)
mat_contents = sio.loadmat('data/DES.mat')
Nside = 512
L_hp = 4 * Nside
L_mw = 2160 # 2160
Iterate = True
save_figs = True
show_figs = True
Npix = hp.nside2npix(Nside)
ra = np.ascontiguousarray(mat_contents['RA'])
ra_flip = (-1) * (ra - 71.) + 71.
dec = np.ascontiguousarray(mat_contents['dec'])
theta, phi = ssht.ra_dec_to_theta_phi(ra_flip, dec, Degrees=True)
pixnum = hp.ang2pix(Nside, theta, phi)
e1 = np.ascontiguousarray(mat_contents['e1'])
e2 = np.ascontiguousarray(mat_contents['e2'])
e2_flip = e2.copy() * (-1)
mcorr = np.ascontiguousarray(mat_contents['mcorr'])
c1 = np.ascontiguousarray(mat_contents['c1'])
c2 = np.ascontiguousarray(mat_contents['c2'])
c2_flip = c2.copy() * (-1)
weight = np.ascontiguousarray(mat_contents['weight'])
alpha = -21 + 180
beta = -37
g = 90
if opts.mapnpz is None: #define sky -- completely arbitrary choice of temp uniform_sky = np.ones(npix)*100.#*u.K #completely arbitrary choice of noise level XXX UN-USED RIGHT NOW noise = np.zeros(npix) for i in range(npix): noise[i] = random.uniform(-100,100)#* u.K ####uniform sky tests and point source tests if opts.map is None: sky=uniform_sky elif opts.map is 'point': sky = np.zeros(npix) #define a point source theta0 = np.pi/2. phi0 = 0. pix0 = hp.ang2pix(nside,theta0,phi0) #make it slightly less point-like nbs = hp.get_all_neighbours(nside,theta0,phi=phi0) sky[pix0]=500#*u.K for nb in nbs: sky[nb]=500#*u.K sky = rotate_hmap(sky,[180,0]) else: sky = hp.read_map(opts.map) #promote sky to matrix for frequency axis sky = np.outer(np.ones(nfreq),sky)*pow(nu/150e6,-0.7) #decompose sky into alm's n_alm = len(m) alm = np.zeros((nfreq,n_alm),dtype='complex128') print 'Calculating sky a_lm values:' for i in range(nfreq):
if nMaps != len(mapRas):
raise valueError
print(nMaps)
goodMap = aveTools.onedl(nMaps)
if p['cutoutMask']:
roundMask = np.round(mask)
else: #just set to ones
roundMask = np.ones(len(healpixMapT))
mapsT = aveTools.onedl(nMaps)
mapsQ = aveTools.onedl(nMaps)
mapsU = aveTools.onedl(nMaps)
centerPixes = healpy.ang2pix(p['mapNside'],
np.pi * (90 - mapDecs) / 180.,
np.pi * mapRas / 180.)
for i in np.arange(nMaps):
if roundMask[centerPixes[i]] == 1:
goodMap[i] = True
print 'good data at ra = %3.1f, dec = %3.1f, pixel %i' % (
mapRas[i], mapDecs[i], i)
mapsT = liteMapNickHand.getEmptyMapAtLocation(tempfilename, mapRas[i],
mapDecs[i])
mapsT.loadDataFromHealpixMap(healpixMapT)
mapsQ = mapsT.copy()
if not os.path.isfile('{}.csv'.format(args.survey)):
fbias_rel_err = np.zeros((n_source_bins, n_lens_bins))
for source_bin in range(n_source_bins):
print('Working on source bin {}...'.format(source_bin))
table_s = zebu.read_raw_data(stage,
'source',
source_bin,
survey=args.survey)
table_s['w_sys'] = 1
table_s['pix'] = healpy.ang2pix(nside,
table_s['ra'],
table_s['dec'],
lonlat=True)
all_pixs = np.unique(table_s['pix'])
use_pixs = np.zeros(0, dtype=np.int)
for pix in all_pixs:
near_pixs = healpy.pixelfunc.get_all_neighbours(nside, pix)
if np.all(np.isin(near_pixs, all_pixs)):
use_pixs = np.append(use_pixs, pix)
table_s = table_s[np.isin(table_s['pix'], use_pixs)]
table_s = add_maximum_lens_redshift(table_s, dz_min=0.15)
if 'd_com' not in table_s.colnames:
table_s['d_com'] = zebu.cosmo.comoving_transverse_distance(
table_s['z']).to(u.Mpc).value
def worker_smallsky(snapshot, z1, z2, batch_index, batches, omega_m, omega_l, boxsize, nside, randomize, seed):
"""
Loads partial batch from snapshot, replicates (along one axis), randomizes if necessary and returns the projected
pixel positions of the particles within the given shell.
Args:
snapshot: Snapshot instance
z1: inner shell redshift
z2: outer shell redshift
batch_index: batch index
batches: total number of batches
omega_m: dark matter density parameter
omega_l: dark energy density parameter
boxsize: snapshot boxsize
nside: HEALPix NSIDE
randomize: randomization flag
seed: randomization seed
Returns: list of particle positions within the given shell on a HEALPix map
"""
particles = snapshot.batch_load(batch_index, batches)
shell_min = d_c(0, z1, omega_m, omega_l) / boxsize
shell_max = d_c(0, z2, omega_m, omega_l) / boxsize
replications = int(np.ceil(shell_max))
replications_boxes = replications
# randomization parameters
if randomize:
np.random.seed(seed)
rand_f = [np.random.randint(2, size=3) for _ in range(0, replications_boxes)]
rand_r = [np.random.randint(4, size=2) * np.pi / 2 for _ in range(0, replications_boxes)]
rand_t = [np.random.rand(3) for _ in range(0, replications_boxes)]
# replicated particle array
_particles = np.zeros((replications_boxes * len(particles), 3), dtype=np.float32)
box_index = 0
for i in range(0, replications):
box_slice = slice(box_index * len(particles), (box_index + 1) * len(particles))
_particles[box_slice] = particles
# randomize
if randomize:
# transformation matrices for flipping/rotating
mat_f = np.matrix([
[1 - 2 * rand_f[box_index][0], 0, 0],
[0, 1 - 2 * rand_f[box_index][1], 0],
[0, 0, 1 - 2 * rand_f[box_index][2]]
])
mat_rx = np.matrix([
[1, 0, 0],
[0, np.cos(rand_r[box_index][0]), -np.sin(rand_r[box_index][0])],
[0, np.sin(rand_r[box_index][0]), np.cos(rand_r[box_index][0])]
])
mat_ry = np.matrix([
[np.cos(rand_r[box_index][1]), 0, np.sin(rand_r[box_index][1])],
[0, 1, 0],
[-np.sin(rand_r[box_index][1]), 0, np.cos(rand_r[box_index][1])]
])
transform = np.dot(np.dot(mat_f, mat_rx), mat_ry)
_particles[box_slice] = np.dot(_particles[box_slice], transform)
_particles[box_slice] += rand_t[box_index]
# wrap particles into their boundaries
for v in range(0, 3):
_particles[box_slice][:, v][np.where(_particles[box_slice][:, v] < -0.5)] += 1
_particles[box_slice][:, v][np.where(_particles[box_slice][:, v] > 0.5)] -= 1
# offset box position
_particles[box_slice][:, 0] += i
box_index += 1
# select particles within shell
observer = np.array([-0.5, 0, 0])
particles = _particles - observer
dist = np.sqrt(np.sum(particles**2, axis=1))
shell = np.array(dist > shell_min) & np.array(dist < shell_max)
# calculate and return the HEALPix positions for all particles within the shell
theta = np.arccos(particles[shell][:, 2] / np.sqrt(np.sum((particles[shell]) ** 2, axis=1)), dtype=np.float32)
phi = np.arctan2(particles[shell][:, 1], particles[shell][:, 0], dtype=np.float32)
pixels = hp.ang2pix(nside, theta, phi, nest=False)
return pixels
# Pixel Count for Healpy
nside = 32
npix = hp.nside2npix(nside)
# Initial Sky Array
n = np.zeros(npix)
# Ranges for Spherical Polar Plotting
thetas = np.linspace(0, np.pi, npix)
phis = np.linspace(0, 2 * np.pi, npix)
thetalim = 5 * np.pi / 8 # 'Aperture Width' of Beam
func = 1 - (((thetas - np.pi) / (thetalim - np.pi))**2) # Beam Function
for j in phis:
pixels = hp.ang2pix(nside, thetas, j)
n[pixels] = func[pixels]
n[n < 0] = 0
filter_array = n # This is the filter to apply to GSM
(latitude, longitude, elevation) = ('-32.998370', '148.263659', 100
) # Near EDGES site
delta_t = 60 # EDGES antenna takes a number of measurements in 24 hours; this is the time between measurements in minutes
sky_array = []
timer = datetime(2018, 1, 1, 0, 0)
while timer.hour < 23:
gsm = GSMObserver()
gsm.lon = longitude
gsm.lat = latitude
gsm.elev = elevation
gsm.date = timer
import fitsio, healpy as hp
import sys, time
#job_server_address = ("dbwebdev.fnal.gov", 8765) #development
job_server_address = ("ifdb01.fnal.gov", 8765) #production
session = Session(job_server_address)
input_file = sys.argv[1]
input_filename = input_file.rsplit("/",1)[-1].rsplit(".",1)[-1]
with T["fits/read"]:
input_data = fitsio.read(input_file, ext=2, columns=["ALPHAWIN_J2000","DELTAWIN_J2000"])
with T["hpix"]:
hpix = hp.ang2pix(nside=16384,theta=input_data['ALPHAWIN_J2000'],phi=input_data['DELTAWIN_J2000'],
lonlat=True, nest=True)
hpix = np.asarray(hpix, np.float64)
input_data = append_fields(input_data, "HPIX", hpix)
np.sort(input_data, order="HPIX")
input_data = np.array(zip(input_data['ALPHAWIN_J2000'], input_data['DELTAWIN_J2000'], input_data['HPIX']))
matches = []
class Callback:
def on_streams_update(self, nevents, data):
if "matches" in data:
for m in data["matches"]:
matches.append(m)
for obs_i, cat_id, obs_ra, obs_dec, cat_ra, cat_dec in m:
def get_map_values(self, index, ra, dec):
pix = hp.ang2pix(self.nside, (-dec + 90.) * N.pi / 180,
ra * N.pi / 180,
nest=1)
return self.syst_maps['values'][index, pix]
def generate_randoms(mask,
max_ndraw,
ra_min=0,
ra_max=360,
dec_min=-90,
dec_max=90,
factor=2):
"""
Generate random points within the footprint
This can be used to generate points distributed uniformly over the entire
footprint for generating a CDF from which to draw mock galaxy positions. It
does not generate the CDF, it merely draws positions from a uniform density
field with the mask applied. Unlike :func:`~.generate_random_points`, this
function generates the points itself rather than calling :mod:`healpix_util`
You should make sure that ``factor`` is large enough that the number of
points generated here, ``int(max_ndraw * factor)``, is enough to sample the
CDF well when ``max_ndraw`` is the maximum final number of mock galaxies to
be drawn in any redshift bin. It needs to be larger than 1, but there is no
guarantee that the default (2) is enough.
:param mask: The pixel coverage mask
:type mask: :class:`lsssys.Mask` or :class:`lsssys.HealMask`
:param max_ndraw: The maximum number of mock galaxies that will be drawn
in any redshift bin. This way, the set of points generated here can be
used to generate the CDF for all of the redshift bins
:type max_ndraw: ``int``
:param ra_min: The minimum right ascension (in degrees) in which the data
will be, to prevent drawing points far from the region of interest.
Default 0.0
:type ra_min: ``float``, optional
:param ra_max: The maximum right ascension (in degrees) in which the data
will be, to prevent drawing points far from the region of interest.
Default 360.0
:type ra_max: ``float``, optional
:param dec_min: The minimum declination (in degrees) in which the data
will be, to prevent drawing points far from the region of interest.
Default -90.0
:type dec_min: ``float``, optional
:param dec_max: The maximum declination (in degrees) in which the data
will be, to prevent drawing points far from the region of interest.
Default 90.0
:type dec_max: ``float``, optional
:param factor: The multiplicative factor on ``max_ndraw`` that sets how many
points should be generated here. This should probably be at least 2, but
that is not checked. Default 2
:type factor: ``int`` or ``float``, optional
:return: An array of right ascension and an array of declination that can be
used with weights to draw mock galaxy positions from the non-uniform
density field with or without systematics
:rtype: 2-``tuple`` of (``int(factor * max_ndraw)``,) :class:`numpy.ndarray`
of ``float``
"""
ra = np.zeros(int(factor * max_ndraw))
dec = np.zeros_like(ra)
nleft = ra.size
nside = mask.nside
if 0 < ra_max < ra_min:
shift_ra = True
ra_range = [ra_min - 360, ra_max]
else:
shift_ra = False
ra_range = [ra_min, ra_max]
while nleft > 0:
# print("Number of points still needed:", nleft, flush=True)
# print("Sphere point pick", flush=True)
new_ra, new_dec = random_points_on_sphere(10 * ra.size, ra_range,
[dec_min, dec_max])
if shift_ra:
new_ra[new_ra < 0] += 360.0
# print("Figure out which points are on good pixels", flush=True)
keep = np.where(
~mask.mask[hp.ang2pix(nside, new_ra, new_dec, lonlat=True)])[0]
if keep.size > 0:
# print(
# "Number of points on good pixels:", keep.size, flush=True)
i_start = ra.size - nleft
nkeep = min(nleft, keep.size)
i_stop = i_start + nkeep
if nkeep < keep.size:
keep = np.random.choice(keep, size=nkeep, replace=False)
# print("Add new points", flush=True)
ra[i_start:i_stop] = new_ra[keep]
dec[i_start:i_stop] = new_dec[keep]
# print("Adjust nleft", flush=True)
nleft -= nkeep
return ra, dec
def characteristic_density(self, iso_sel):
"""
Compute the characteristic density of a region
Convlve the field and find overdensity peaks
"""
x, y = self.proj.sphereToImage(self.data[self.survey.catalog['basis_1']][iso_sel], self.data[self.survey.catalog['basis_2']][iso_sel]) # Trimmed magnitude range for hotspot finding
#x_full, y_full = proj.sphereToImage(data[basis_1], data[basis_2]) # If we want to use full magnitude range for significance evaluation
delta_x = 0.01
area = delta_x**2
smoothing = 2. / 60. # Was 3 arcmin
bins = np.arange(-8., 8. + 1.e-10, delta_x)
centers = 0.5 * (bins[0: -1] + bins[1:])
yy, xx = np.meshgrid(centers, centers)
h = np.histogram2d(x, y, bins=[bins, bins])[0]
h_g = scipy.ndimage.filters.gaussian_filter(h, smoothing / delta_x)
#cut_goodcoverage = (data['NEPOCHS_G'][cut_magnitude_threshold] >= 2) & (data['NEPOCHS_R'][cut_magnitude_threshold] >= 2)
# expect NEPOCHS to be good in DES data
delta_x_coverage = 0.1
area_coverage = (delta_x_coverage)**2
bins_coverage = np.arange(-5., 5. + 1.e-10, delta_x_coverage)
h_coverage = np.histogram2d(x, y, bins=[bins_coverage, bins_coverage])[0]
#h_goodcoverage = np.histogram2d(x[cut_goodcoverage], y[cut_goodcoverage], bins=[bins_coverage, bins_coverage])[0]
h_goodcoverage = np.histogram2d(x, y, bins=[bins_coverage, bins_coverage])[0]
n_goodcoverage = h_coverage[h_goodcoverage > 0].flatten()
#characteristic_density = np.mean(n_goodcoverage) / area_coverage # per square degree
characteristic_density = np.median(n_goodcoverage) / area_coverage # per square degree
print('Characteristic density = {:0.1f} deg^-2'.format(characteristic_density))
# Use pixels with fracdet ~1.0 to estimate the characteristic density
if self.fracdet is not None:
fracdet_zero = np.tile(0., len(self.fracdet))
cut = (self.fracdet != hp.UNSEEN)
fracdet_zero[cut] = self.fracdet[cut]
nside_fracdet = hp.npix2nside(len(self.fracdet))
subpix_region_array = []
for pix in np.unique(hp.ang2pix(self.nside,
self.data[self.survey.catalog['basis_1']][iso_sel],
self.data[self.survey.catalog['basis_2']][iso_sel],
lonlat=True)):
subpix_region_array.append(subpixel(self.pix_center, self.nside, nside_fracdet))
subpix_region_array = np.concatenate(subpix_region_array)
# Compute mean fracdet in the region so that this is available as a correction factor
cut = (self.fracdet[subpix_region_array] != hp.UNSEEN)
mean_fracdet = np.mean(self.fracdet[subpix_region_array[cut]])
# Correct the characteristic density by the mean fracdet value
characteristic_density_raw = 1. * characteristic_density
characteristic_density /= mean_fracdet
print('Characteristic density (fracdet corrected) = {:0.1f} deg^-2'.format(characteristic_density))
return(characteristic_density)
start = time.time()
NSIDE = 256
NPIX = hp.nside2npix(NSIDE)
NPIX
day = 60 * 60 * 24 #1日の秒数
year = day * 365
times = year + 1
time_array = np.arange(0, times, 1)
print("Calcurate orbit...")
#orbit = spin_prec(time_array)
#orbit = hp.vec2ang(orbit)
orbit_file = "/Users/yusuke/program/py_program/CMB/skymap/regenerate_s/orbit_angle.npz"
orbit = np.load(orbit_file)
orbit = np.array([orbit["theta"][:times], orbit["phi"][:times]])
pix = hp.ang2pix(NSIDE, orbit[0], orbit[1])
#ヒストグラムの処理は長い
print("Calcurate orbit histogram...")
hit_pix, bins = np.histogram(pix, bins=NPIX)
"""Planckのマップをreadして解析する"""
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
I_obs
I_map = np.zeros((3, NPIX))
I_map[0][pix[:]] = I_planck[0][pix]
I_map[1][pix[:]] = I_planck[1][pix]
def written_as_a_function_to_save_memory(z_bins, randoms, result):
print('loading SuperCosmos catalog and mask...')
catalog = np.load('datalog/wisecatalog_z.npy') #ra,deg,z
#print(catalog.shape)
scosmask = healpy.read_map('WISExSCOSmask.fits')
num = 30000000
#coord=SkyCoord(catalog[0],catalog[1],frame='galactic',unit='deg').icrs
#catalog[0],catalog[1]=coord.ra.deg,coord.dec.deg
coord = SkyCoord(catalog[0], catalog[1], frame='icrs', unit='deg').galactic
l, b = coord.l.deg, coord.b.deg
catalog = catalog[:, scosmask[healpy.ang2pix(
256, l, b, nest=False, lonlat=True)] == 1]
'''
print(catalog.shape)
print('z_min:',np.min(catalog[2]),'z_max:',np.max(catalog[2]))
plt.hist(catalog[2],100)
plt.xlabel('z')
plt.ylabel('# of galaxies')
plt.title('SuperCosmos z histogram(masked)')
plt.show()
plt.scatter(catalog[0],catalog[1],c=catalog[2],s=0.005,cmap='rainbow',edgecolors='none')
plt.xlabel('RA(deg)')
plt.ylabel('DEC(deg)')
plt.title('SuperCosmos redshift scatter plot(masked)')
plt.colorbar()
plt.show()
raw_input=()
'''
catalog = catalog[:, catalog[2].argsort()]
if z_bins == 3:
catalog = catalog[:, catalog[0].size / 4 * z_bins:]
else:
catalog = catalog[:, catalog[0].size / 4 * z_bins:catalog[0].size / 4 *
(z_bins + 1)]
if z_bins == 0:
catalog = catalog[:, catalog[2] >= 0.01]
#print('bin',z_bins,'size',catalog[2].shape,'z range',catalog[2,0],'~',catalog[2,-1])
#catalog=catalog[:,catalog[0].size]
#cat_galaxy=treecorr.Catalog(ra=catalog[0],dec=catalog[1],ra_units='deg',dec_units='deg',k=np.ones(catalog[0].size))
cat_galaxy = treecorr.Catalog(ra=catalog[0],
dec=catalog[1],
ra_units='deg',
dec_units='deg')
print('Done!\n')
print 'generating random galaxy catalog'
#plt.scatter(catalog[0],catalog[1],s=0.01)
#plt.xlabel('RA(deg)')
#plt.ylabel('DEC(deg)')
#plt.show()
ra_min = np.min(cat_galaxy.ra)
ra_max = np.max(cat_galaxy.ra)
dec_min = np.min(cat_galaxy.dec)
dec_max = np.max(cat_galaxy.dec)
print('ra range = %f .. %f' % (ra_min, ra_max))
print('dec range = %f .. %f' % (dec_min, dec_max))
rand_ra = np.random.uniform(ra_min, ra_max, num)
rand_sindec = np.random.uniform(np.sin(dec_min), np.sin(dec_max), num)
rand_dec = np.arcsin(rand_sindec)
coord = SkyCoord(rand_ra, rand_dec, frame='icrs', unit='rad').galactic
l, b = coord.l.deg, coord.b.deg
rand_ra = rand_ra[scosmask[healpy.ang2pix(
256, l, b, nest=False, lonlat=True)] == 1]
rand_dec = rand_dec[scosmask[healpy.ang2pix(
256, l, b, nest=False, lonlat=True)] == 1]
#plt.scatter(np.rad2deg(rand_ra),np.rad2deg(rand_dec),s=0.01)
#plt.xlabel('RA(deg)')
#plt.ylabel('DEC(deg)')
#plt.show()
print('Done!\n')
cat_rand = treecorr.Catalog(ra=rand_ra,
dec=rand_dec,
ra_units='radians',
dec_units='radians')
#load planck data
print('loading Planck catalog and mask...')
planckdata = fits.open('COM_CMB_IQU-smica-nosz_2048_R3.00_full.fits')
planckmask = fits.open('HFI_Mask_GalPlane-apo0_2048_R2.00.fits')
planckImap = planckdata[1].data['I_STOKES']
planckImask = planckmask[1].data['GAL080']
planckdata.close()
planckmask.close()
planckpix = np.arange(0, planckImap.size)
planckImap = planckImap[planckImask == 1]
planckpix = planckpix[planckImask == 1]
planck_ra, planck_dec = healpy.pix2ang(nside=2048,
ipix=planckpix,
nest=True,
lonlat=True)
coord = SkyCoord(planck_ra, planck_dec, frame='galactic', unit='deg').icrs
planck_ra, planck_dec = coord.ra.deg, coord.dec.deg
cat_planck = treecorr.Catalog(ra=planck_ra,
dec=planck_dec,
ra_units='deg',
dec_units='deg',
k=planckImap)
print('Done!\n')
print('calculating cross-relation...')
nk = treecorr.NKCorrelation(min_sep=0.01,
max_sep=10,
nbins=35,
sep_units='deg')
rk = treecorr.NKCorrelation(min_sep=0.01,
max_sep=10,
nbins=35,
sep_units='deg')
nk.process(cat_galaxy, cat_planck)
rk.process(cat_rand, cat_planck)
xi, varxi = nk.calculateXi(rk)
sig = np.sqrt(varxi)
r = np.exp(nk.meanlogr)
#print xi
print('Done!\n')
#print('Plotting')
#plt.plot(r, xi, color='blue')
#plt.errorbar(r[xi>0], xi[xi>0], yerr=sig[xi>0], lw=1, ls='',ecolor='g')
#leg = plt.errorbar(-r, xi, yerr=sig, color='blue')
#plt.xscale('log')
#plt.xlabel(r'$\theta$ (degrees)')
#plt.ylabel(r'$w(\theta)$')
#plt.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
#plt.legend([leg], [r'$w(\theta)$'], loc='lower left')
#plt.title('SuperCosmos x Planck at {} z bin'.format(str(z_bins)))
#plt.show()
#np.save('datalog/SuperCosmos_z_{}.npy'.format(str(z_bins)),np.array([xi,r,sig]))
result[z_bins, randoms] = np.array([xi, r, sig])
print randoms, ' runs'
print('{} bins datalog saved!'.format(str(z_bins)))
nk.clear()
rk.clear()
cat_galaxy.clear_cache()
cat_rand.clear_cache()
cat_planck.clear_cache()
catalog = None
scosmask = None
coord = None
l = None
b = None
ra_min, ra_max, dec_min, dec_max = None, None, None, None
rand_ra, rand_sindec, rand_dec = None, None, None
planck_ra, planck_dec = None, None
planckImap, planckpix = None, None
xi, r, sig, varxi = None, None, None, None
return result
def characteristic_density_local(self, iso_sel, x_peak, y_peak, angsep_peak):
"""
Compute the local characteristic density of a region
"""
#characteristic_density = self.characteristic_density(iso_sel)
characteristic_density = self.density
x, y = self.proj.sphereToImage(self.data[self.survey.catalog['basis_1']][iso_sel], self.data[self.survey.catalog['basis_2']][iso_sel]) # Trimmed magnitude range for hotspot finding
#x_full, y_full = proj.sphereToImage(data[basis_1], data[basis_2]) # If we want to use full magnitude range for significance evaluation
# If fracdet map is available, use that information to either compute local density,
# or in regions of spotty coverage, use the typical density of the region
if self.fracdet is not None:
# The following is copied from how it's used in compute_char_density
fracdet_zero = np.tile(0., len(self.fracdet))
cut = (self.fracdet != hp.UNSEEN)
fracdet_zero[cut] = self.fracdet[cut]
nside_fracdet = hp.npix2nside(len(self.fracdet))
subpix_region_array = []
for pix in np.unique(hp.ang2pix(self.nside,
self.data[self.survey.catalog['basis_1']][iso_sel],
self.data[self.survey.catalog['basis_2']][iso_sel],
lonlat=True)):
subpix_region_array.append(subpixel(self.pix_center, self.nside, nside_fracdet))
subpix_region_array = np.concatenate(subpix_region_array)
# Compute mean fracdet in the region so that this is available as a correction factor
cut = (self.fracdet[subpix_region_array] != hp.UNSEEN)
mean_fracdet = np.mean(self.fracdet[subpix_region_array[cut]])
subpix_region_array = subpix_region_array[self.fracdet[subpix_region_array] > 0.99]
subpix = hp.ang2pix(nside_fracdet,
self.data[self.survey.catalog['basis_1']][cut_magnitude_threshold][iso_sel],
self.data[self.survey.catalog['basis_2']][cut_magnitude_threshold][iso_sel],
lonlat=True)
# This is where the local computation begins
ra_peak, dec_peak = self.proj.imageToSphere(x_peak, y_peak)
subpix_all = hp.query_disc(nside_fracet, hp.ang2vec(ra_peak, dec_peak, lonlat=True), np.radians(0.5))
subpix_inner = hp.query_disc(nside_fracet, hp.ang2vec(ra_peak, dec_peak, lonlat=True), np.radians(0.3))
subpix_annulus = subpix_all[~np.in1d(subpix_all, subpix_inner)]
mean_fracdet = np.mean(fracdet_zero[subpix_annulus])
print('mean_fracdet {}'.format(mean_fracdet))
if mean_fracdet < 0.5:
characteristic_density_local = characteristic_density
print('characteristic_density_local baseline {}'.format(characteristic_density_local))
else:
# Check pixels in annulus with complete coverage
subpix_annulus_region = np.intersect1d(subpix_region_array, subpix_annulus)
print('{} percent pixels with complete coverage'.format(float(len(subpix_annulus_region)) / len(subpix_annulus)))
if (float(len(subpix_annulus_region)) / len(subpix_annulus)) < 0.25:
characteristic_density_local = characteristic_density
print('characteristic_density_local spotty {}'.format(characteristic_density_local))
else:
characteristic_density_local = float(np.sum(np.in1d(subpix, subpix_annulus_region))) \
/ (hp.nside2pixarea(nside_fracdet, degrees=True) * len(subpix_annulus_region)) # deg^-2
print('characteristic_density_local cleaned up {}'.format(characteristic_density_local))
else:
# Compute the local characteristic density
area_field = np.pi * (0.5**2 - 0.3**2)
n_field = np.sum((angsep_peak > 0.3) & (angsep_peak < 0.5))
characteristic_density_local = n_field / area_field
# If not good azimuthal coverage, revert
cut_annulus = (angsep_peak > 0.3) & (angsep_peak < 0.5)
#phi = np.degrees(np.arctan2(y_full[cut_annulus] - y_peak, x_full[cut_annulus] - x_peak)) # Use full magnitude range, NOT TESTED!!!
phi = np.degrees(np.arctan2(y[cut_annulus] - y_peak, x[cut_annulus] - x_peak)) # Impose magnitude threshold
h = np.histogram(phi, bins=np.linspace(-180., 180., 13))[0]
if np.sum(h > 0) < 10 or np.sum(h > 0.5 * np.median(h)) < 10:
#angsep_peak = np.sqrt((x - x_peak)**2 + (y - y_peak)**2)
characteristic_density_local = characteristic_density
print('Characteristic density local = {:0.1f} deg^-2 = {:0.3f} arcmin^-2'.format(characteristic_density_local, characteristic_density_local / 60.**2))
return(characteristic_density_local)
ra, dec = pixelname.radec_of(az_scan, alt)
ra_arr[z] = (ra)
dec_arr[z] = (dec)
ra_arrs.append(ra_arr)
dec_arrs.append(dec_arr)
#convert to healpix and plot...
#wait... healpy functions need DEC in the range 0,pi, so convert DEC
hp_decs = [np.pi / 2. - dec_arrs[j] for j in range(len(dec_arrs))]
print hp_decs
NSIDE = 128 #resolution of the map
npix = hp.nside2npix(NSIDE)
nhits_tot = np.zeros(npix)
for k in range(len(hp_decs)):
healIndex = hp.ang2pix(NSIDE, hp_decs[k],
ra_arrs[k]) #index in healpy - ring format
nhits = np.bincount(healIndex, minlength=npix)
nhits_tot += nhits
print nhits_tot
#show the map
hp.mollview(nhits_tot, title='Hit map')
'''
plt.figure()
plt.plot(azimuths,elevations,'r.')
plt.show()
'''
if (len(args.in_dir) > 8) and (args.in_dir[-8:] == ".fits.gz"):
fi = glob.glob(args.in_dir)
else:
fi = glob.glob(args.in_dir + "/*.fits.gz")
fi = sorted(fi)
data = {}
ndata = 0
for i, f in enumerate(fi):
if i % 10 == 0:
print("\rread {} of {} {}".format(i, len(fi), ndata), end="")
hdus = fitsio.FITS(f)
dels = [delta.from_fitsio(h) for h in hdus[1:]]
ndata += len(dels)
phi = [d.ra for d in dels]
th = [sp.pi / 2 - d.dec for d in dels]
pix = healpy.ang2pix(cf.nside, th, phi)
for d, p in zip(dels, pix):
if not p in data:
data[p] = []
data[p].append(d)
z = 10**d.ll / args.lambda_abs - 1.
z_min_pix = sp.amin(sp.append([z_min_pix], z))
d.r_comov = cosmo.r_comoving(z)
if not args.old_deltas:
d.we *= ((1. + z) / (1. + args.z_ref))**(cf.alpha - 1.)
if not args.no_project:
d.project()
if not args.nspec is None:
if ndata > args.nspec: break
print("")
def find_peaks(self, iso_sel):
"""
Convolve field to find characteristic density and peaks within the selected pixel
"""
#characteristic_density = self.characteristic_density(iso_sel)
characteristic_density = self.density
x, y = self.proj.sphereToImage(self.data[self.survey.catalog['basis_1']][iso_sel], self.data[self.survey.catalog['basis_2']][iso_sel]) # Trimmed magnitude range for hotspot finding
#x_full, y_full = proj.sphereToImage(data[basis_1], data[basis_2]) # If we want to use full magnitude range for significance evaluation
delta_x = 0.01
area = delta_x**2
smoothing = 2. / 60. # Was 3 arcmin
bins = np.arange(-8., 8. + 1.e-10, delta_x)
#bins = np.arange(-4., 4. + 1.e-10, delta_x) # SM: not sure what to prefer here...
centers = 0.5 * (bins[0: -1] + bins[1:])
yy, xx = np.meshgrid(centers, centers)
h = np.histogram2d(x, y, bins=[bins, bins])[0]
h_g = scipy.ndimage.filters.gaussian_filter(h, smoothing / delta_x)
# SM: If we can speed up this block that would be great
factor_array = np.arange(1., 5., 0.05)
rara, decdec = self.proj.imageToSphere(xx.flatten(), yy.flatten())
cutcut = (hp.ang2pix(self.nside, rara, decdec, lonlat=True) == self.pix_center).reshape(xx.shape)
threshold_density = 5 * characteristic_density * area
for factor in factor_array:
# This is reducing the contrast against the background through the arbitrary measurement 'factor'
# until there are fewer than 10 disconnected peaks
h_region, n_region = scipy.ndimage.measurements.label((h_g * cutcut) > (area * characteristic_density * factor))
#print 'factor', factor, n_region, n_region < 10
if n_region < 10:
threshold_density = area * characteristic_density * factor
break
h_region, n_region = scipy.ndimage.measurements.label((h_g * cutcut) > threshold_density)
#h_region = np.ma.array(h_region, mask=(h_region < 1))
x_peak_array = []
y_peak_array = []
angsep_peak_array = []
for index in range(1, n_region + 1): # loop over peaks
#index_peak = np.argmax(h_g * (h_region == index))
index_peak = np.ravel_multi_index(scipy.ndimage.maximum_position(input=h_g, labels=h_region, index=index), h_g.shape)
x_peak, y_peak = xx.flatten()[index_peak], yy.flatten()[index_peak]
#print index, np.max(h_g * (h_region == index))
# SM: Could these numbers be useful?
#index_max = scipy.ndimage.maximum(input=h_g, labels=h_region, index=index)
#index_stddev = scipy.ndimage.standard_deviation(input=h_g, labels=h_region, index=index)
#print('max: {}'.format(index_max))
#print('stddev: {}'.format(index_stddev))
#angsep_peak = np.sqrt((x_full - x_peak)**2 + (y_full - y_peak)**2) # Use full magnitude range, NOT TESTED!!!
angsep_peak = np.sqrt((x-x_peak)**2 + (y-y_peak)**2)
x_peak_array.append(x_peak)
y_peak_array.append(y_peak)
angsep_peak_array.append(angsep_peak)
return x_peak_array, y_peak_array, angsep_peak_array
moonSunSep = np.array(moonSunSep)
moonTargetSep = np.array(moonTargetSep)
moonAzDiff = moonTargetSep * 0
targetAlt = np.pi / 2. - np.arccos(1. / moonAM)
# Compute the azimuth difference given the moon-target-seperation
# Let's just do a stupid loop:
for i in np.arange(targetAlt.size):
possibleDistances = haversine(0., np.radians(moonAlt[i]), az,
az * 0 + targetAlt[i])
diff = np.abs(possibleDistances - np.radians(moonTargetSep[i]))
good = np.where(diff == diff.min())
try:
moonAzDiff[i] = az[good][0]
# ok, now I have an alt and az, I can convert that back to a healpix id.
hpid.append(hp.ang2pix(nside, np.pi / 2. - targetAlt[i],
moonAzDiff[i]))
except:
import pdb
pdb.set_trace()
if diff.min() > 1e-5:
import pdb
pdb.set_trace()
nrec = moonAM.size
nwave = moonWave.size
dtype = [('hpid', 'int'), ('moonAltitude', 'float'), ('moonSunSep', 'float'),
('spectra', 'float', (nwave)), ('mags', 'float', (6))]
moonSpectra = np.zeros(nrec, dtype=dtype)
moonSpectra['hpid'] = hpid
moonSpectra['moonAltitude'] = moonAlt
xsize = 1000
ysize = xsize / 2.
linthresh = 0.1
# this is the mollview min and max
vmin = 0
vmax = nbins[-1]
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)
width = 24
cmap = plt.cm.RdYlBu
colormaptag = "colombi1_"
data = [mask_func(nside) for mask_func in mask_funcs]
fig = plt.figure(figsize=(cm2inch(width), cm2inch(width) * .8))
figure_rows, figure_columns = 2, 2
for i, (submap, nbin) in enumerate(zip(data, nbins)):
# matplotlib is doing the mollveide projection
submap = pebbles.plotting.apply_so_mask(submap)
ax = plt.subplot(figure_rows,
figure_columns,
def findTract(self, coord):
"""Find the tract whose inner region includes the coord."""
theta, phi = coordToAng(coord)
index = healpy.ang2pix(self._nside, theta, phi, nest=self.config.nest)
return self[index]
def produce_forests(self):
"""
randomly creates Lya forests for testing
"""
userprint("\n")
nside = 8
### Load DRQ
vac = fitsio.FITS(self._branchFiles + "/Products/cat.fits")
ra = vac[1]["RA"][:] * np.pi / 180.
dec = vac[1]["DEC"][:] * np.pi / 180.
thid = vac[1]["THING_ID"][:]
plate = vac[1]["PLATE"][:]
mjd = vac[1]["MJD"][:]
fiberid = vac[1]["FIBERID"][:]
vac.close()
### Get Healpy pixels
pixs = healpy.ang2pix(nside, np.pi / 2. - dec, ra)
### Save master file
path = self._branchFiles + "/Products/Spectra/master.fits"
head = {}
head['NSIDE'] = nside
cols = [thid, pixs, plate, mjd, fiberid]
names = ['THING_ID', 'PIX', 'PLATE', 'MJD', 'FIBER']
out = fitsio.FITS(path, 'rw', clobber=True)
out.write(cols, names=names, header=head, extname="MASTER TABLE")
out.close()
### Log lambda grid
logl_min = 3.550
logl_max = 4.025
logl_step = 1.e-4
log_lambda = np.arange(logl_min, logl_max, logl_step)
### Loop over healpix
for p in np.unique(pixs):
### Retrieve objects from catalog and produce fake spectra
p_thid = thid[(pixs == p)]
p_fl = np.random.normal(loc=1.,
scale=1.,
size=(log_lambda.size, p_thid.size))
p_iv = np.random.lognormal(mean=0.1,
sigma=0.1,
size=(log_lambda.size, p_thid.size))
p_am = np.zeros((log_lambda.size, p_thid.size)).astype(int)
p_am[np.random.random_sample(size=(log_lambda.size,
p_thid.size)) > 0.90] = 1
p_om = np.zeros((log_lambda.size, p_thid.size)).astype(int)
### Save to file
p_path = self._branchFiles + "/Products/Spectra/pix_" + str(
p) + ".fits"
out = fitsio.FITS(p_path, 'rw', clobber=True)
out.write(p_thid, header={}, extname="THING_ID_MAP")
out.write(log_lambda, header={}, extname="LOGLAM_MAP")
out.write(p_fl, header={}, extname="FLUX")
out.write(p_iv, header={}, extname="IVAR")
out.write(p_am, header={}, extname="ANDMASK")
out.write(p_om, header={}, extname="ORMASK")
out.close()
return
