def Setdistance(nside):
"""Returns a table of distance between each HEALPix pixel in radians.
"""
NPIX = hppf.nside2npix(nside)
print 'Array', NPIX, 'x', NPIX
nparr_dist = np.zeros((NPIX, NPIX))
for (ipix, npar_pix) in enumerate(nparr_dist):
for (jpix, rad_pix) in enumerate(npar_pix):
rad_pix = hp.rotator.angdist(hppf.pix2ang(nside, ipix), hppf.pix2ang(nside, jpix))
nparr_dist[ipix][jpix] = rad_pix
np.save('PixelsDistance_{0}.npy'.format(nside), nparr_dist)
return nparr_dist # In radians
def equirectangular2heapix(data, nside, data_x=None, data_y=None, nest=True, manual_phi_correction=0):
if data_x is None:
delx = 2*np.pi / (data.shape[1] - 1)
data_x = np.arange(0, 2*np.pi+delx/100., delx)
if data_y is None:
dely = np.pi / (data.shape[0] - 1)
data_y = np.arange(np.pi, -dely/100., -dely)
if data.shape != (len(data_y), len(data_x)):
raise ValueError("Input shape mismatch between %s and (%i, %i)"%(data.shape, len(data_y), len(data_x)))
inter_f = si.interp2d(sorted(data_x), sorted(data_y), data[np.ix_(np.argsort(data_y), np.argsort(data_x))])
result = np.empty(12*nside**2, dtype=data.dtype)
heal_thetas, heal_phis = hpf.pix2ang(nside, range(12*nside**2), nest=nest)
unique_heal_thetas = np.unique(heal_thetas)
for heal_theta in unique_heal_thetas:
theta_mask = heal_thetas == heal_theta
#doing some complicated juggling bc interp function automatically sort the list input and output according to that implicitly re-arranged inuput list
qaz_phis = (heal_phis[theta_mask] + manual_phi_correction) % (np.pi*2)
qaz = np.zeros_like(heal_phis[theta_mask])
qaz[np.argsort(qaz_phis)] = inter_f(np.sort(qaz_phis), heal_theta).flatten()
result[theta_mask] = qaz
# if np.abs(heal_theta - np.pi/2.) < 5*np.pi/180.:
# print np.isnan(qaz).all()
# print np.isnan(data).all()
# print data_x
# print data_y
return result
def get_fitting_region(order,pixel):
"""Expand tile by quarter of a pixel for fitting
:param order: the HEALPix resolution level
:param pixel: given HEALPix pixel that needs to be fit
:return: HEALPix pixels that need to be fit
"""
#define old and new order
old_nside=2**order
new_nside=2**(order+2)
#get co-ord of main pixel
theta,phi=pixelfunc.pix2ang(old_nside, pixel, nest=True)
#define offsets such that main pixel is split into four sub pixels
scale=pixelfunc.max_pixrad(old_nside)
offset_theta=np.array([-0.125,0.0,0.125,0.0])*scale
offset_phi=np.array([0.0,-0.125,0.0,0.125])*scale
#convert co-ords to pixels at higher order
pix_fit=pixelfunc.ang2pix(new_nside, theta+offset_theta, phi+offset_phi, nest=True)
#get neighbouring pixels and remove duplicates
moc_tile=MOC()
pixels=np.unique(pixelfunc.get_all_neighbours(new_nside, pix_fit,nest=True))
moc_tile.add(order+2,np.unique(pixelfunc.get_all_neighbours(new_nside, pixels,nest=True)))
return moc_tile
def rotate_healpixmap(healpixmap, z1, y1, z2):#the three rotation angles are (fixed rotation axes and right hand convention): rotate around z axis by z1, around y axis by y1, and z axis again by z2. I think they form a set of Euler angles, but not exactly sure.
nside = int((len(healpixmap)/12.)**.5)
if len(healpixmap)%12 != 0 or 12*(nside**2) != len(healpixmap):
raise Exception('ERROR: Input healpixmap length %i is not 12*nside**2!'%len(healpixmap))
newmapcoords_in_oldcoords = [rotatez(rotatey(rotatez(hpf.pix2ang(nside, i), -z2), -y1), -z1) for i in range(12*nside**2)]
newmap = [hpf.get_interp_val(healpixmap, coord[0], coord[1]) for coord in newmapcoords_in_oldcoords]
return newmap
def inv_projmap(self, img, nside=None):
"""Inverse projection of the projected map to a healpix spherical map.
Input:
- img: an array cantains the projected map.
Return:
- a 1D array contains the healpix spherical map.
"""
ysize, xsize = img.shape
if nside is None:
lonra = self.arrayinfo['lonra']
latra = self.arrayinfo['latra']
npix = np.int(
(360.0 * xsize / (lonra[1] - lonra[0])) *
(180.0 * ysize / (latra[1] - latra[0]))) # the total pixel
nside = 2**np.int(np.ceil(np.log2(np.sqrt(npix / 12.0)) - 1))
npix = 12 * nside**2
hpmap = np.zeros(npix, dtype=img.dtype)
theta, phi = pixelfunc.pix2ang(
nside,
np.arange(npix)) # in radians, theta: [0, pi], phi: [0. 2pi]
x = np.degrees(phi)
x = -np.where(x > 180.0, x - 360.0, x) # [-180.0, 180.0]
y = -np.degrees(theta) + 90.0 # [-90.0, 90.0]
for pix in np.arange(npix):
i, j = self.xy2ij(x[pix], y[pix])
if i is not None and j is not None:
hpmap[pix] = img[i, j]
return hpmap
def rotate_healpixmap(healpixmap, z1, y1, z2):#the three rotation angles are (fixed rotation axes and right hand convention): rotate around z axis by z1, around y axis by y1, and z axis again by z2. I think they form a set of Euler angles, but not exactly sure.
nside = int((len(healpixmap)/12.)**.5)
if len(healpixmap)%12 != 0 or 12*(nside**2) != len(healpixmap):
raise Exception('ERROR: Input healpixmap length %i is not 12*nside**2!'%len(healpixmap))
newmapcoords_in_oldcoords = [rotatez(rotatey(rotatez(hpf.pix2ang(nside, i), -z2), -y1), -z1) for i in range(12*nside**2)]
newmap = [hpf.get_interp_val(healpixmap, coord[0], coord[1]) for coord in newmapcoords_in_oldcoords]
return newmap
def __init__(self,
resolution: u.Quantity = 1*u.deg,
time: Time = Time.now(),
frequency: u.Quantity = 50*u.MHz,
polarization: np.ndarray = np.array([0]),
value: Union[float, np.ndarray] = 0.,
observer: EarthLocation = nenufar_position
):
if hpx is None:
log.error(
f"Unable to create an instance of {self.__qualname__} since 'healpy' does not work."
)
self.nside, self.resolution = self._resol2nside(resolution=resolution)
# Construct the Healpix coordinates map
ra, dec = hpx.pix2ang(
nside=self.nside,
ipix=np.arange(
hpx.nside2npix(self.nside),
dtype=np.int64
),
lonlat=True,
nest=False
)
super().__init__(
coordinates=SkyCoord(ra, dec, unit="deg"),
time=time,
frequency=frequency,
polarization=polarization,
value=value,
observer=observer
)
def inv_projmap(self, img, nside=None):
"""Inverse projection of the projected map to a healpix spherical map.
Input:
- img: an array cantains the projected map.
Return:
- a 1D array contains the healpix spherical map.
"""
ysize, xsize = img.shape
if nside is None:
lonra = self.arrayinfo['lonra']
latra = self.arrayinfo['latra']
npix = np.int((360.0 * xsize / (lonra[1] - lonra[0])) * (180.0 * ysize / (latra[1] - latra[0]))) # the total pixel
nside = 2**np.int(np.ceil(np.log2(np.sqrt(npix/12.0)) - 1))
npix = 12 * nside**2
hpmap = np.zeros(npix, dtype=img.dtype)
theta, phi = pixelfunc.pix2ang(nside, np.arange(npix)) # in radians, theta: [0, pi], phi: [0. 2pi]
x = np.degrees(phi)
x = -np.where(x>180.0, x-360.0, x) # [-180.0, 180.0]
y = -np.degrees(theta) + 90.0 # [-90.0, 90.0]
for pix in np.arange(npix):
i, j = self.xy2ij(x[pix], y[pix])
if i is not None and j is not None:
hpmap[pix] = img[i, j]
return hpmap
def get_fitting_region(order, pixel):
"""Expand tile by quarter of a pixel for fitting
:param order: the HEALPix resolution level
:param pixel: given HEALPix pixel that needs to be fit
:return: HEALPix pixels that need to be fit
"""
#define old and new order
old_nside = 2**order
new_nside = 2**(order + 2)
#get co-ord of main pixel
theta, phi = pixelfunc.pix2ang(old_nside, pixel, nest=True)
#define offsets such that main pixel is split into four sub pixels
scale = pixelfunc.max_pixrad(old_nside)
offset_theta = np.array([-0.125, 0.0, 0.125, 0.0]) * scale
offset_phi = np.array([0.0, -0.125, 0.0, 0.125]) * scale
#convert co-ords to pixels at higher order
pix_fit = pixelfunc.ang2pix(new_nside,
theta + offset_theta,
phi + offset_phi,
nest=True)
#get neighbouring pixels and remove duplicates
moc_tile = MOC()
pixels = np.unique(
pixelfunc.get_all_neighbours(new_nside, pix_fit, nest=True))
moc_tile.add(
order + 2,
np.unique(pixelfunc.get_all_neighbours(new_nside, pixels, nest=True)))
return moc_tile
def test_josh_gsm(self):
self.result = {}
colors = ['r', 'b', 'c', 'g']
for self.nside, color in zip([32, 64, 128, 256], colors):
nside = self.nside
pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' +
str(nside))
pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' +
str(nside))
pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' +
str(nside))
gsm = 422.952 * (0.307706 * pca1 + -0.281772 * pca2 +
0.0123976 * pca3)
equatorial_GSM = np.zeros(12 * nside**2, 'float')
#rotate sky map
for i in range(12 * nside**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside, i))
equatorial_GSM[i] = hpf.get_interp_val(gsm, ang[0], ang[1])
self.alm = sv.convert_healpy_alm(
hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1)
timer = time.time()
self.result[nside] = self.vs.calculate_visibility(
sv.expand_real_alm(self.alm),
d=self.rot.dot(np.array([15.0, 21.0, 0.0])),
freq=self.freq,
nt=len(self.correct_result) - 1,
L=3 * self.nside - 1,
verbose=False)
print(time.time() - timer) / 60., "minutes for nside = %i" % nside
sys.stdout.flush()
plt.plot(np.real(self.result[nside]), '%s--' % color)
#plt.plot(np.real(self.correct_result), 'g--')
#plt.plot(np.real(self.result32), 'r--', np.real(self.result64), 'b--', np.real(self.correct_result), 'g--')
plt.show()
def healpix_to_skycoord(pix, nside=None):
"""
given a healpix pix and the nside level of the healpix return the SkyCoord representing the centre of the field
"""
if nside is None:
nside = HEALPIX_NSIDE
ra, dec = pixelfunc.pix2ang(nside, pix, lonlat=True)
return SkyCoord(ra, dec, unit='degree')
def rotate_healpixmap(healpixmap, z1, y1, z2):#the three rotation angles are (fixed rotation axes and right hand convention): rotate around z axis by z1, around y axis by y1, and z axis again by z2. I think they form a set of Euler angles, but not exactly sure.
nside = int((len(healpixmap)/12.)**.5)
if len(healpixmap)%12 != 0 or 12*(nside**2) != len(healpixmap):
raise Exception('ERROR: Input healpixmap length %i is not 12*nside**2!'%len(healpixmap))
rot_matrix = rotatez_matrix(-z1).dot(rotatey_matrix(-y1).dot(rotatez_matrix(-z2)))
new_coords = hpf.pix2ang(nside, range(12*nside**2))
old_coords = hpr.rotateDirection(rot_matrix, new_coords)
newmap = hpf.get_interp_val(healpixmap, old_coords[0], old_coords[1])
return newmap
def test_speed(self):
self.test_dir = os.path.dirname(os.path.realpath(__file__)) + '/'
self.blmequ = sv.read_real_alm(self.test_dir + 'bx125.195.bin')
self.blmax = 5
self.freq = 125.195#my correct answers are computed with c=300,so im rescaing freq here to compensate
self.zenithequ = sv.ctos(np.fromfile(self.test_dir + 'zenith.bin', dtype = 'float32'))[1:]
self.zenithequ[0] = np.pi/2 - self.zenithequ[0]
self.zenithequ = np.array(self.zenithequ)[::-1]
self.correct_result = np.loadtxt(self.test_dir + 'Revised_Location_Visibilties_for_21_m_south_21_m_east_0_m_up_xx_pol_125.195_MHz.dat')
self.correct_result = self.correct_result[:-1, 1] + 1j * self.correct_result[:-1, 2]
self.nside = 128
self.vs = sv.Visibility_Simulator()
self.vs.initial_zenith = self.zenithequ
self.vs.Blm = sv.expand_real_alm(self.blmequ)
self.rot = np.fromfile(self.test_dir + 'x5rot.bin', dtype = 'float32').reshape((3,3))
nside = self.nside
print "Reading fits...",
sys.stdout.flush()
pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside))
pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside))
pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside))
gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3)
print "Done reading"
sys.stdout.flush()
equatorial_GSM = np.zeros(12*nside**2,'float')
#rotate sky map
print "Rotating map...",
sys.stdout.flush()
for i in range(12*nside**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i))
pixindex, weight = hpf.get_neighbours(nside,ang[0],ang[1])
for pix in range(len(pixindex)):
equatorial_GSM[i] += weight[pix]*gsm[pixindex[pix]]
print "Done rotating"
sys.stdout.flush()
print "Creating map alm...",
sys.stdout.flush()
self.alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1)
print "Done alm"
sys.stdout.flush()
print "Computing visibilities...",
sys.stdout.flush()
timer = time.time()
self.result = self.vs.calculate_visibility(sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([21.0,21.0,0.0])), freq=self.freq, nt=len(self.correct_result), L = 3*self.nside-1, verbose = True)
print "done", (time.time() - timer)/60, 'min'
sys.stdout.flush()
#print len(self.result), np.argmax(np.real(self.result)) - np.argmax(np.real(self.correct_result)), np.argmax(np.imag(self.result)) - np.argmax(np.imag(self.correct_result))
plt.plot(np.real(self.result), 'r--', np.real(self.correct_result), 'b--')
plt.show()
plt.plot(np.imag(self.result), 'r--', np.imag(self.correct_result), 'b--')
plt.show()
def _get_eq_coords(self):
""" Compute the equatorial and horizontal coordinates
for the HEALPix sky
"""
ra, dec = pix2ang(nside=self.nside,
ipix=self.pixidx,
lonlat=True,
nest=False)
ra *= u.deg
dec *= u.deg
self._eq_coords = SkyCoord(ra, dec, frame='icrs')
return
def tile_in_tile(order_small,tile_small,order_large):
"""Routine to find our what larger tile to load data from when fitting smaller tiles.
Returns larger tile no. Useful for when fitting segmented maps on HPC using a hierarchical segmentation scheme
:param order_small: order of smaller tile
:param tile_small: tile no. of smaller tile
:param order_large: order of larger tiling scheme
:return: pixel number of larger tile
"""
theta, phi =pixelfunc.pix2ang(2**order_small, tile_small, nest=True)
ipix = pixelfunc.ang2pix(2**order_large, theta, phi, nest=True)
return ipix
def tile_in_tile(order_small, tile_small, order_large):
"""Routine to find our what larger tile to load data from when fitting smaller tiles.
Returns larger tile no. Useful for when fitting segmented maps on HPC using a hierarchical segmentation scheme
:param order_small: order of smaller tile
:param tile_small: tile no. of smaller tile
:param order_large: order of larger tiling scheme
:return: pixel number of larger tile
"""
theta, phi = pixelfunc.pix2ang(2**order_small, tile_small, nest=True)
ipix = pixelfunc.ang2pix(2**order_large, theta, phi, nest=True)
return ipix
def find_galoff_healpxs(nhpside=16, threshold_flux50=0, path_catalogue_excl='/nfs/farm/g/glast/u/mtakahas/data/catalogue/gll_psch_v09.fit'):
"""Returns a list of HEALPiX pixles which satisfy your conditions as OFF region of Galactic ridge. The coordinate system is RADEC.
"""
NPIX = hppf.nside2npix(nhpside)
MAX_PIX_DEG = degrees(hppf.max_pixrad(nhpside))
ar_pix_incl = []
for ipix in range(NPIX):
theta, phi = hppf.pix2ang(nhpside, ipix)
radec_rad = [phi, pi/2.-theta] #[pi/2.-theta, phi]
radec_deg = [degrees(radec_rad[0]), degrees(radec_rad[1])]
gal_deg = convert_radec_to_galactic(radec_deg)
if abs(gal_deg[1])>=50 and 90<=gal_deg[0]<270:
ar_ang_dist = calcAngDist_Catalogue(radec_deg, path_catalogue_excl, threshold_flux50)
for di in ar_ang_dist:
if di['ANG_DIST']<=MAX_PIX_DEG:
break
else:
ar_pix_incl.append(ipix)
return ar_pix_incl
def horizon_mask(self, zenith, radius=45):
""" Mask the healpix map pixels that are below a given
radius from the local zenith.
:param zenith:
Array of local zenith converted in Galactic
coordinates. This might typically be
:attr:`SphUVW.zen_gal`
:type zenith: `np.ndarray`
:param radius:
Radius from zenith, below which mask pixels
:type radius: float
"""
if radius == 0:
return np.ones(nside2npix(self._hpsize), dtype='bool')
# Theta coordinates of the healpix map
theta, phi = pix2ang(self._hpsize,
np.arange(nside2npix(self._hpsize)),
lonlat=True)
# Convert theta to longitudes
t_mask = theta > np.pi
theta[t_mask] = (2. * np.pi - theta[t_mask]) * -1.
pix_coord = np.deg2rad(np.vstack([theta, phi])[..., np.newaxis])
# Galactiv coordinates
gal_l = np.array([z.l.deg for z in zenith])
gal_b = np.array([z.b.deg for z in zenith])
gal_coord = np.deg2rad(np.vstack([gal_l, gal_b])[:, np.newaxis])
# Difference between two sets of angles
lon1, lon2 = gal_coord[0], pix_coord[0]
lat1, lat2 = gal_coord[1], pix_coord[1]
c1 = np.cos(lat1)
c2 = np.cos(lat2)
s1 = np.sin(lat1)
s2 = np.sin(lat2)
cd = np.cos(lon2 - lon1)
sd = np.sin(lon2 - lon1)
u = np.square(c2 * sd) + np.square(c1 * s2 - s1 * c2 * cd)
d = s1 * s2 + c1 + c2 * cd
dist = np.arctan2(u.flatten(), d.flatten()).reshape(u.shape)
# Mask evrything below horizon, i.e. keep if raidus < 45deg
return ~np.any(np.rad2deg(dist) < radius, axis=1)
def test_josh_gsm(self):
self.nside = 32
nside = self.nside
pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside))
pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside))
pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside))
gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3)
equatorial_GSM = np.zeros(12*nside**2,'float')
#rotate sky map
for i in range(12*nside**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i))
equatorial_GSM[i] = hpf.get_interp_val(gsm, ang[0], ang[1])
self.alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1)
self.result32 = self.vs.calculate_visibility(sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([6.0,3.0,0.0])), freq=self.freq, nt=len(self.correct_result)-1, L = 3*self.nside-1, verbose = False)
print self.result32[0], self.result32[-1]
print self.correct_result[0], self.correct_result[-1]
#self.nside = 64
#nside = self.nside
#pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside))
#pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside))
#pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside))
#gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3)
#equatorial_GSM = np.zeros(12*nside**2,'float')
##rotate sky map
#for i in range(12*nside**2):
#ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i))
#pixindex, weight = hpf.get_neighbours(nside,ang[0],ang[1])
#for pix in range(len(pixindex)):
#equatorial_GSM[i] += weight[pix]*gsm[pixindex[pix]]
#self.alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1)
#self.result64 = self.vs.calculate_visibility(sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([6.0,3.0,0.0])), freq=self.freq, nt=len(self.correct_result)-1, L = 3*self.nside-1, verbose = False)
#plt.plot(np.real(self.result32), 'r--', np.real(self.result64), 'b--', np.real(self.correct_result), 'g--')
#plt.show()
#plt.plot(np.imag(self.result32), 'r--', np.imag(self.result64), 'b--', np.imag(self.correct_result), 'g--')
#plt.show()
plt.plot(np.real(self.result32), 'r--', np.real(self.correct_result), 'g--')
plt.show()
def test_josh_gsm(self):
self.result = {}
colors = ['r','b','c','g']
for self.nside, color in zip([32, 64, 128, 256], colors):
nside = self.nside
pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside))
pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside))
pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside))
gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3)
equatorial_GSM = np.zeros(12*nside**2,'float')
#rotate sky map
for i in range(12*nside**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i))
equatorial_GSM[i] = hpf.get_interp_val(gsm, ang[0], ang[1])
self.alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1)
timer = time.time()
self.result[nside] = self.vs.calculate_visibility(sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([15.0,21.0,0.0])), freq=self.freq, nt=len(self.correct_result)-1, L = 3*self.nside-1, verbose = False)
print (time.time() - timer)/60., "minutes for nside = %i"%nside
sys.stdout.flush();
plt.plot(np.real(self.result[nside]), '%s--'%color)
#plt.plot(np.real(self.correct_result), 'g--')
#plt.plot(np.real(self.result32), 'r--', np.real(self.result64), 'b--', np.real(self.correct_result), 'g--')
plt.show()
else:
raise Exception('Cant tell if the iinfo is for PAPER or MITEoR')
vs.initial_zenith = np.array([0, lat_degree*np.pi/180])#self.zenithequ
beam_heal_equ = np.array(sv.rotate_healpixmap(beam_healpix, 0, np.pi/2 - vs.initial_zenith[1], vs.initial_zenith[0]))
timer = time.time()
if all_ubl:
ubls = infoubl
else:
ubls = [ubl for ubl in infoubl if la.norm(ubl) < inclusion_thresh * (nside_target * 299.792458 / freq)]
print "%i UBLs to include"%len(ubls)
if len(tlist)*len(ubls) < 12*nside**2:
for i in range(5):
print 'Not enough degree of freedom! %i*%i<%i.'%(len(tlist), len(ubls), 12*nside**2)
A = np.empty((len(tlist)*len(ubls), 12*nside**2), dtype='complex64')
for i in range(12*nside**2):
dec, ra = hpf.pix2ang(nside, i)#gives theta phi
dec = np.pi/2 - dec
print "%.1f%%"%(100.*float(i)/(12.*nside**2)),
sys.stdout.flush()
A[:, i] = np.array([vs.calculate_pointsource_visibility(ra, dec, d, freq, beam_heal_equ = beam_heal_equ, tlist = tlist) for d in ubls]).flatten()
print float(time.time()-timer)/60.
if all_ubl:
A.tofile('/home/omniscope/data/GSM_data/Amatrix_allubl_nside%i_%iby%i_'%(nside, len(A), len(A[0])) + infofile.split('/')[-1])
else:
A.tofile('/home/omniscope/data/GSM_data/Amatrix_%iubl_nside%i_%iby%i_'%(len(ubls), nside, len(A), len(A[0])) + infofile.split('/')[-1])
def model(self, TP_HTG_KING, HTG2_LIVETIME, NHPSIDE=256, THRESHOLD_ANGDIST=15, tpl_path_perf=('/nfs/farm/g/glast/u/mtakahas/v20r09p09_G1haB1/S18/S18V200909_020RAWE20ZDIR020ZCS000wwoTRKwoMCZDIR00woRWcatTwo_15/S18ZDIR020catTwoZDIR060_E28binx_Cth40bins_CalOnly_R100_perf.root', '/nfs/farm/g/glast/u/mtakahas/v20r09p09_G1haB1/S18/S18V200909_020RAWE20ZDIR020ZCS000wwoTRKwoMCZDIR00woRWcatTwo_15/S18ZDIR020catTwoZDIR060_E28binx_Cth40bins_CalOnly_R30_perf.root', '/nfs/farm/g/glast/u/mtakahas/v20r09p09_G1haB1/S18/S18V200909_020RAWE20ZDIR020ZCS000wwoTRKwoMCZDIR00woRWcatTwo_15/S18ZDIR020catTwoZDIR060_E28binx_Cth40bins_CalOnly_R10_perf.root'), aeff_regular=None):
"""Model the point source with the PSF of King function. Energy dispersion is ignored currently.
"""
PIX_TRUE = hppf.ang2pix(NHPSIDE, pi/2.-self.DEC_RAD, self.RA_RAD) # #Pixel the true position of the source locates in
TP_DIR_TRUE = (pi/2.-self.DEC_RAD, self.RA_RAD)
print 'NSIDE:', NHPSIDE
NPIX = hppf.nside2npix(NHPSIDE)
print NPIX, 'pixels.'
print 'Pixel resolution:', degrees(hppf.nside2resol(NHPSIDE)), 'deg'
sa_pix = hppf.nside2pixarea(NHPSIDE) # Solid angle of a pixel [sr]
print 'Solid angle of each pixel:', sa_pix, 'sr'
coo_src = SkyCoord(self.RA, self.DEC, unit="deg") # True coordinate of the source
THRESHOLD_ANGDIST_RADIANS = radians(THRESHOLD_ANGDIST)
self.dctt_htg_sed_model_enr[NHPSIDE] = {}
htg_aeff_regular = None
if aeff_regular!=None:
file_aeff_regular = ROOT.TFile(aeff_regular, 'READ')
htg_aeff_regular = file_aeff_regular.Get('htgEaRegular')
print htg_aeff_regular.GetName()
# ROI
set_pix_roi = set([])
dict_angdist = {}
for ipix in range(NPIX):
tp_pix = hppf.pix2ang(NHPSIDE, ipix)
dict_angdist[ipix] = hp.rotator.angdist(tp_pix, TP_DIR_TRUE) # Angular distance between the source and each pixel in radians
if dict_angdist[ipix] < THRESHOLD_ANGDIST_RADIANS:
set_pix_roi.add(ipix)
print 'ROI pixels:', set_pix_roi
HTG1_LT = HTG2_LIVETIME.ProjectionX("{0}_projTheta".format(HTG2_LIVETIME.GetName()), 1, HTG2_LIVETIME.GetYaxis().FindBin(self.ZENITH_CUT)-1)
# Preparation of ON region setup
dct_path_perf = {}
dct_file_perf = {}
dct_htg_psf95 = {}
dct_htg_acc = {}
# PSF
fc_King_annulus = ROOT.TF1("fc_King_annulus", "TMath::Sin(x)*[0]*(1.-1./[2])*pow(1.+(x/[1])**2/2./[2],-[2])/[1]**2", 0, pi)
fc_King = ROOT.TF1("fc_King", "[0]*(1.-1./[2])*pow(1.+(x/[1])**2/2./[2],-[2])/2./TMath::Pi()/[1]**2", 0, pi)
for (icla,cla) in enumerate(self.TPL_STR_CLASS):
print '======================='
print cla
print '======================='
dct_path_perf[cla] = tpl_path_perf[icla]
dct_file_perf[cla] = ROOT.TFile(dct_path_perf[cla], 'READ')
dct_htg_psf95[cla] = dct_file_perf[cla].Get('psf_q95_hist')
dct_htg_acc[cla] = dct_file_perf[cla].Get('acc_cth_hist')
htg2_model = ROOT.TH2D("htg2_model_{0}_NSIDE{1}".format(cla, NHPSIDE), "Model of {0} {1} (NSIDE={2})".format(cla, self.NAME, NHPSIDE), NPIX, 0, NPIX, self.NBIN_ENERGY, self.EDGE_ENERGY_LOW, self.EDGE_ENERGY_UP)
htg2_model_on = htg2_model.Clone('{0}_ON'.format(htg2_model.GetName()))
htg_sed_model = ROOT.TH2D('htg_sed_model_{0}'.format(cla), 'SED model of {0} {1}'.format(cla, self.NAME), self.HTG_SED.GetNbinsX(), self.HTG_SED.GetXaxis().GetXmin(), self.HTG_SED.GetXaxis().GetXmax(), dct_htg_acc[cla].GetNbinsY(), dct_htg_acc[cla].GetYaxis().GetXmin(), dct_htg_acc[cla].GetYaxis().GetXmax())
for iEne in range(1, self.HTG_SED.GetNbinsX()+1):
print 'Energy:', self.HTG_SED.GetXaxis().GetBinLowEdge(iEne), '-', self.HTG_SED.GetXaxis().GetBinUpEdge(iEne)
flux_true_itgl = self.HTG_SED.GetBinContent(iEne)
fluxerr_true_itgl = self.HTG_SED.GetBinError(iEne)
print ' Flux:', flux_true_itgl, '+/-', fluxerr_true_itgl, '[photons cm^-2 s^-1]'
for iTh in range(1, HTG1_LT.GetNbinsX()+1):
scale_aeff = dct_htg_acc[cla].GetBinContent(dct_htg_acc[cla].GetXaxis().FindBin(self.HTG_SED.GetXaxis().GetBinCenter(iEne)), dct_htg_acc[cla].GetYaxis().FindBin(HTG1_LT.GetXaxis().GetBinCenter(iTh))) / (2*math.pi*dct_htg_acc[cla].GetYaxis().GetBinWidth(dct_htg_acc[cla].GetYaxis().FindBin(HTG1_LT.GetXaxis().GetBinCenter(iTh)))) # Effective area [m^2]
if htg_aeff_regular!=None:
#print '=-=-=-=-='
#print scale_aeff
scale_aeff = scale_aeff + htg_aeff_regular.GetBinContent(htg_aeff_regular.GetXaxis().FindBin(10**self.HTG_SED.GetXaxis().GetBinCenter(iEne)), htg_aeff_regular.GetYaxis().FindBin(HTG1_LT.GetXaxis().GetBinCenter(iTh)))
#print scale_aeff
scale_exp = scale_aeff * 100.**2 * HTG1_LT.GetBinContent(iTh) # Integrated exposure value for a certain energy and inclination angle [cm^2 s]
nphoton = flux_true_itgl*scale_exp
nphotonerr = fluxerr_true_itgl*scale_exp
htg_sed_model.Fill(htg_sed_model.GetXaxis().GetBinCenter(iEne), htg_sed_model.GetYaxis().GetBinCenter(iTh), nphoton)
kxbin = TP_HTG_KING[0].GetXaxis().FindBin(self.HTG_SED.GetXaxis().GetBinCenter(iEne))
kybin = TP_HTG_KING[0].GetYaxis().FindBin(HTG1_LT.GetBinCenter(iTh))
if nphoton>0 and kxbin>0 and kybin>0:
print ' cos(Inclination angle):', HTG1_LT.GetXaxis().GetBinLowEdge(iTh), '-', HTG1_LT.GetXaxis().GetBinUpEdge(iTh)
print ' Effective area:', scale_aeff, 'm^2'
print ' Exposure:', scale_exp, 'cm^2 s'
print ' Number of photons:', nphoton, '+/-', nphotonerr
print ''
for ipar in range(3): # Setting the parameters of King function
# PSF
par_value = TP_HTG_KING[ipar].GetBinContent(kxbin, kybin)
#print ' Parameter No.{0}:'.format(ipar), par_value
fc_King_annulus.FixParameter(ipar, par_value)
fc_King.FixParameter(ipar, par_value)
factor_norm = 1.0/fc_King_annulus.Integral(0, pi)
#print ' Normalization factor:', factor_norm
for ipix in set_pix_roi:
scale_psf = fc_King.Eval(dict_angdist[ipix])
htg2_model.Fill(ipix+0.5, htg2_model.GetYaxis().GetBinCenter(iEne), nphoton*scale_psf*factor_norm*sa_pix)
# for cla in self.TPL_STR_CLASS:
deg_psf95 = dct_htg_psf95[cla].GetBinContent(dct_htg_psf95[cla].FindBin(self.HTG_SED.GetBinCenter(iEne)))
if radians(min(15, deg_psf95))>dict_angdist[ipix]:
htg2_model_on.SetBinContent(ipix, iEne, 1)
else:
htg2_model_on.SetBinContent(ipix, iEne, 0)
if self.HTG_SED.GetBinContent(iEne)!=0:
htg_sed_model.SetBinError(iEne, iTh, self.HTG_SED.GetBinError(iEne)/self.HTG_SED.GetBinContent(iEne)*htg_sed_model.GetBinContent(iEne, iTh))
else:
htg_sed_model.SetBinError(iEne, iTh, 0)
print htg2_model_on.Integral()
htg2_model_on.Multiply(htg2_model)
for ienr in range(1, htg2_model_on.GetYaxis().GetNbins()+1):
for ipix in range(1, htg2_model_on.GetXaxis().GetNbins()+1):
content = htg2_model.GetBinContent(ipix, ienr)
content_err = htg2_model.GetBinError(ipix, ienr)
content_on = htg2_model_on.GetBinContent(ipix, ienr)
if content>0:
htg2_model_on.SetBinError(ipix, ienr, content_err*content_on/content)
else:
htg2_model_on.SetBinError(ipix, ienr, 0)
print htg2_model_on.Integral()
htg_sed_model_on = htg2_model_on.ProjectionY('{0}_ON'.format(htg_sed_model.GetName()))
print 'ON photon number:', htg_sed_model_on.Integral()
htg_sed_model_enr = htg_sed_model.ProjectionX('{0}_projEnergy'.format(htg_sed_model.GetName()))
for ienr in range(1, htg_sed_model_on.GetXaxis().GetNbins()+1):
content = htg_sed_model_enr.GetBinContent(ienr)
content_err = htg_sed_model_enr.GetBinError(ienr)
content_on = htg_sed_model_on.GetBinContent(ienr)
if content>0:
htg_sed_model_on.SetBinError(ienr, content_err*content_on/content)
else:
htg_sed_model_on.SetBinError(ienr, 0)
print 'Making map...'
arr_map = []
arr_map_energy = []
for iEne in range(0, self.HTG_SED.GetNbinsX()+1):
arr_map.append([])
if iEne>0:
arr_map_energy.append((self.HTG_SED.GetXaxis().GetBinLowEdge(iEne), self.HTG_SED.GetXaxis().GetBinUpEdge(iEne)))
for ipix in range(htg2_model.GetXaxis().GetNbins()):
if ipix in set_pix_roi:
arr_map[-1].append(htg2_model.GetBinContent(ipix+1, iEne))
else:
arr_map[-1].append(hppf.UNSEEN)
else:
arr_map_energy.append((self.HTG_SED.GetXaxis().GetBinLowEdge(1), self.HTG_SED.GetXaxis().GetBinUpEdge(self.HTG_SED.GetNbinsX())))
for ipix in range(htg2_model.GetXaxis().GetNbins()):
if ipix in set_pix_roi:
arr_map[-1].append(htg2_model.Integral(ipix+1, ipix+1, 1, htg2_model.GetNbinsY()))
else:
arr_map[-1].append(hppf.UNSEEN)
print ' Energy:', arr_map_energy[-1][0], '-', arr_map_energy[-1][1]
nparr_map = np.array(arr_map[-1]) # Take this energy bin
hp.visufunc.cartview(nparr_map, iEne, self.tp_rotate, unit='cm^-2 s^-1 / {0:.1E} sr'.format(sa_pix), lonra=[-THRESHOLD_ANGDIST, THRESHOLD_ANGDIST], latra=[-THRESHOLD_ANGDIST, THRESHOLD_ANGDIST], title='{0} ({1:.3f} - {2:.3f} GeV)'.format(self.NAME, pow(10, arr_map_energy[-1][0]-3), pow(10, arr_map_energy[-1][1]-3)), min=0, flip='astro')
plt.savefig("png/Model-{0}_{1}_NSIDE{2}_{3}-{4}.png".format(self.NAME, cla, NHPSIDE, int(100*arr_map_energy[-1][0]+0.5), int(100*arr_map_energy[-1][1]+0.5)))
plt.close()
self.FILE_OUT.cd()
htg_sed_model.Write()
htg_sed_model_enr.Write()
htg2_model.Write()
htg_sed_model_on.Write()
self.dctt_htg_sed_model_enr[NHPSIDE][cla] = copy.copy(htg_sed_model_enr)
self.HTG_SED.Write()
if all_ubl:
ubls = infoubl
else:
ubls = [
ubl for ubl in infoubl
if la.norm(ubl) < inclusion_thresh * (nside_target * 299.792458 / freq)
]
print "%i UBLs to include" % len(ubls)
if len(tlist) * len(ubls) < 12 * nside**2:
for i in range(5):
print 'Not enough degree of freedom! %i*%i<%i.' % (
len(tlist), len(ubls), 12 * nside**2)
A = np.empty((len(tlist) * len(ubls), 12 * nside**2), dtype='complex64')
for i in range(12 * nside**2):
dec, ra = hpf.pix2ang(nside, i) #gives theta phi
dec = np.pi / 2 - dec
print "%.1f%%" % (100. * float(i) / (12. * nside**2)),
sys.stdout.flush()
A[:, i] = np.array([
vs.calculate_pointsource_visibility(ra,
dec,
d,
freq,
beam_heal_equ=beam_heal_equ,
tlist=tlist) for d in ubls
]).flatten()
print float(time.time() - timer) / 60.
if all_ubl:
A.tofile('/home/omniscope/data/GSM_data/Amatrix_allubl_nside%i_%iby%i_' %
def colorcode(i):
return abs(hpf.pix2ang(mother_nside, i, nest=True)[0] - np.pi/2)/(np.pi/2)
A[p] = np.fromfile(A_filename, dtype='complex64').reshape((len(ubls), len(tlist), 12*nside_beamweight**2))[:,tmask].reshape((len(ubls)*len(tlist[tmask]), 12*nside_beamweight**2))
else:
#beam
beam_healpix = local_beam[p](freq)
#hpv.mollview(beam_healpix, title='beam %s'%p)
#plt.show()
vs = sv.Visibility_Simulator()
vs.initial_zenith = np.array([0, lat_degree*np.pi/180])#self.zenithequ
beam_heal_equ = np.array(sv.rotate_healpixmap(beam_healpix, 0, np.pi/2 - vs.initial_zenith[1], vs.initial_zenith[0]))
print "Computing A matrix for %s pol..."%p
sys.stdout.flush()
timer = time.time()
A[p] = np.empty((len(tlist)*len(ubls), 12*nside_beamweight**2), dtype='complex64')
for i in range(12*nside_beamweight**2):
dec, ra = hpf.pix2ang(nside_beamweight, i)#gives theta phi
dec = np.pi/2 - dec
print "\r%.1f%% completed, %f minutes left"%(100.*float(i)/(12.*nside_beamweight**2), (12.*nside_beamweight**2-i)/(i+1)*(float(time.time()-timer)/60.)),
sys.stdout.flush()
A[p][:, i] = np.array([vs.calculate_pointsource_visibility(ra, dec, d, freq, beam_heal_equ = beam_heal_equ, tlist = tlist) for d in ubls]).flatten()
print "%f minutes used"%(float(time.time()-timer)/60.)
sys.stdout.flush()
A[p].tofile(A_filename)
A[p] = A[p].reshape((len(ubls), len(tlist), 12*nside_beamweight**2))[:,tmask].reshape((len(ubls)*len(tlist[tmask]), 12*nside_beamweight**2))
####################################################
###beam weights using an equal pixel A matrix######
#################################################
print "Computing beam weight...",
#plt.show()
vs = sv.Visibility_Simulator()
vs.initial_zenith = np.array([0, lat_degree * np.pi / 180
]) #self.zenithequ
beam_heal_equ = np.array(
sv.rotate_healpixmap(beam_healpix, 0,
np.pi / 2 - vs.initial_zenith[1],
vs.initial_zenith[0]))
print "Computing A matrix for %s pol..." % p
sys.stdout.flush()
timer = time.time()
A[p] = np.empty((len(tlist) * len(ubls), 12 * nside**2),
dtype='complex64')
for i in range(12 * nside**2):
dec, ra = hpf.pix2ang(nside, i) #gives theta phi
dec = np.pi / 2 - dec
print "\r%.1f%% completed, %f minutes left" % (
100. * float(i) / (12. * nside**2), (12. * nside**2 - i) /
(i + 1) * (float(time.time() - timer) / 60.)),
sys.stdout.flush()
A[p][:, i] = np.array([
vs.calculate_pointsource_visibility(
ra, dec, d, freq, beam_heal_equ=beam_heal_equ, tlist=tlist)
for d in ubls
]).flatten()
print "%f minutes used" % (float(time.time() - timer) / 60.)
sys.stdout.flush()
A[p].tofile(A_filename)
def K_RJ2MJysr(K_RJ, nu):#in Kelvin and Hz
conversion_factor = 2 * (nu / c)**2 * kB
return K_RJ * conversion_factor * 1e20#1e-26 for Jy and 1e6 for MJy
TRJ_mask = original_freqs < 20
TCMB_mask = (original_freqs >= 20) & (original_freqs < 500)
original_idata[TRJ_mask] = K_RJ2MJysr(1., original_freqs[TRJ_mask] * 1e9)[:, None] * original_idata[TRJ_mask]
original_idata[TCMB_mask] = K_CMB2MJysr(1., original_freqs[TCMB_mask] * 1e9)[:, None] * original_idata[TCMB_mask]
###############################
##start loop
estimated_data = []
latitude_masks = [np.ones(mother_npix, dtype=bool)]
n_latitude_regions = 2
gal_lat = np.abs(np.pi / 2 - hpf.pix2ang(mother_nside, range(mother_npix), nest=True)[0])
lat_width = np.pi / 2 / n_latitude_regions
for n_lat in range(n_latitude_regions):
latitude_masks.append((gal_lat >= n_lat * lat_width) & (gal_lat < (n_lat + 1) * lat_width))
estimation_errors = [[] for i in range(1 + n_latitude_regions)]
estimation_renorm_errors = [[] for i in range(1 + n_latitude_regions)]
pseudo_estimation_errors = [[] for i in range(1 + n_latitude_regions)]
for remove_f in range(-1, len(original_idata)):
removed_idata = np.copy(original_idata[remove_f])
removed_freq = np.copy(original_freqs[remove_f])
idata = original_idata[np.array([f for f in range(len(original_idata)) if f != remove_f])]
freqs = original_freqs[np.array([f for f in range(len(original_freqs)) if f != remove_f])]
##############################################
##############################################
####start I data processing method 1
##############################################
metStart = float(par[2])
metStop = float(par[3])
if len(par)>4:
pathCatalogue = par[4]
else:
pathCatalogue = "/disk/gamma/cta/store/takhsm/FermiData/catalogue/gll_psch_v09.fit"
print "Time domain:", metStart, "-", metStop
# ON/OFF regions
NHPSIDE_OFF = 16
aHpxOFF = [find_galoff_healpxs(NHPSIDE_OFF, 0, pathCatalogue)]
print aHpxOFF
aCoordsPix_array = [[]]
aAreaPix_array = [[]]
aStrRegion = ["GalacticOFF"]
for npix in aHpxOFF[0]:
aAngPix = hppf.pix2ang(NHPSIDE_OFF, npix)
aCoordsPix_array[0].append(SkyCoord(aAngPix[1], pi/2-aAngPix[0], unit="rad"))
aAreaPix_array[0].append(hppf.nside2pixarea(NHPSIDE_OFF, npix))
# Output objects
aFileToI = []
fileRoot = ROOT.TFile("Livetime_GalacticOff_{0}.root".format(nameFileSuffix), "update")
aHtgLt = []
for hRegion in range(len(aStrRegion)):
aHtgLt.append(ROOT.TH3D("htgLt_{0}".format(aStrRegion[hRegion]), "Livetime over {0} [sec sr];Cos(Inclination angle);Zenith angle [deg];Time[sec]".format(aStrRegion[hRegion]), 40, 0.2, 1.0, 180, 0, 180, max(10, int(metStop-metStart)/54000), metStart, metStop+1))
make_livetime_histogram(aHtgLt, len(aStrRegion), pathFileScAll, metStart, metStop, aFileToI, aCoordsPix_array, aAreaPix_array)
aHtgLt_projYX = []
fileRoot.cd()
for jR in range(len(aStrRegion)):
aHtgLt[jR].Write()
aHtgLt_projYX.append(aHtgLt[jR].Project3D("yx"))
'/home/omniscope/simulate_visibilities/data/gsm1.fits' +
str(nside_standard))
pca2 = hp.fitsfunc.read_map(
'/home/omniscope/simulate_visibilities/data/gsm2.fits' +
str(nside_standard))
pca3 = hp.fitsfunc.read_map(
'/home/omniscope/simulate_visibilities/data/gsm3.fits' +
str(nside_standard))
gsm_standard = 422.952 * (0.307706 * pca1 + -0.281772 * pca2 +
0.0123976 * pca3)
equatorial_GSM_standard = np.zeros(12 * nside_standard**2, 'float')
#rotate sky map
print "Rotating GSM_standard...",
sys.stdout.flush()
for i in range(12 * nside_standard**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside_standard, i))
equatorial_GSM_standard[i] = hpf.get_interp_val(gsm_standard, ang[0],
ang[1])
print "done."
sys.stdout.flush()
if nside != nside_standard:
if nside > 4:
pca1 = hp.fitsfunc.read_map(
'/home/omniscope/simulate_visibilities/data/gsm1.fits' +
str(nside))
pca2 = hp.fitsfunc.read_map(
'/home/omniscope/simulate_visibilities/data/gsm2.fits' +
str(nside))
pca3 = hp.fitsfunc.read_map(
'/home/omniscope/simulate_visibilities/data/gsm3.fits' +
def test(temp, file_path):
import time
import numpy as np
import pandas as pd
import healpy.pixelfunc as pf
####################
# DF definition
####################
filter_set = ['u', 'g', 'r', 'i', 'z']
filter_set = [f'{fs}_ap'
for fs in filter_set] + [f'{fs}_ab' for fs in filter_set]
zrange = [[0.0, 0.3], [0.3, 0.6], [0.6, 0.9], [0.9, 1.2], [1.2, 2.5]]
####################
# Create galaxies
####################
temp = np.linspace(22.8, 24.8, 1000)
temp = {f: temp for f in filter_set}
temp['id_galaxy'] = np.arange(1000)
####################
# Position galaxies
####################
'''A ring order is used for this set.'''
pix_region = pf.get_all_neighbours(32,
theta=90,
phi=0,
nest=False,
lonlat=True)
pix_region = np.concatenate([
pix_region,
np.array([pf.ang2pix(32, 90, 0, nest=False, lonlat=True)])
])
pix_map = np.zeros(pf.nside2npix(32))
pix_map[pix_region] = 1
pix_map = pf.ud_grade(pix_map, 64, order_in='RING', order_out='RING')
pix_region = np.arange(pf.nside2npix(64))[pix_map > 0]
ra_region, dec_region = pf.pix2ang(64, pix_region, nest=False, lonlat=True)
data = []
for i in range(len(pix_region)):
for j in range(len(zrange)):
temp['ra'] = ra_region[i]
temp['dec'] = dec_region[i]
temp['zobs'] = (zrange[j][0] + zrange[j][1]) / 2
data.append(pd.DataFrame(temp))
data = pd.concat(data)
big_pixels = pf.ang2pix(32,
data['ra'],
data['dec'],
nest=False,
lonlat=True)
big_pixel_ID = np.unique(big_pixels)
####################
# File save
####################
fnames = []
for pix in big_pixel_ID:
fname = f'{file_path}galaxies_test_{pix}.csv'
fnames.append(fname)
data_subset = data.loc[big_pixels == pix]
data_subset.to_csv(fname, index=False)
print('Test data created')
return (fnames)
sys.stdout.flush()
A[p] = np.fromfile(A_path, dtype='complex64').reshape((len(ubls) * nt_used, 12 * nside_beamweight ** 2))
else:
# beam
if p == 'x':
beam_heal_equ = beam_heal_equ_x
elif p == 'y':
beam_heal_equ = beam_heal_equ_x
print "Computing sky weighting A matrix for %s pol..." % p
sys.stdout.flush()
A[p] = np.zeros((nt_used * len(ubls), 12 * nside_beamweight ** 2), dtype='complex64')
timer = time.time()
for i in np.arange(12 * nside_beamweight ** 2):
dec, ra = hpf.pix2ang(nside_beamweight, i) # gives theta phi
dec = np.pi / 2 - dec
print "\r%.1f%% completed" % (100. * float(i) / (12. * nside_beamweight ** 2)),
sys.stdout.flush()
if abs(dec - lat_degree * np.pi / 180) <= np.pi / 2:
A[p][:, i] = vs.calculate_pointsource_visibility(ra, dec, ubls, freq, beam_heal_equ=beam_heal_equ, tlist=tlist).flatten()
print "%f minutes used" % (float(time.time() - timer) / 60.)
sys.stdout.flush()
A[p].tofile(A_path)
####################################################
###beam weights using an equal pixel A matrix######
#################################################
print "Computing beam weight...",
sys.stdout.flush()
A_filename = datadir + tag + '_%s%s_%i_%i.Agsm'%(p, p, len(tlist)*len(ubls), 12*nside**2)
if os.path.isfile(A_filename) and not force_recompute:
print A_filename + " already exists."
else:
#beam
beam_healpix = local_beam[p](freq)
#hpv.mollview(beam_healpix, title='beam %s'%p)
#plt.show()
vs = sv.Visibility_Simulator()
vs.initial_zenith = np.array([0, lat_degree*np.pi/180])#self.zenithequ
beam_heal_equ = np.array(sv.rotate_healpixmap(beam_healpix, 0, np.pi/2 - vs.initial_zenith[1], vs.initial_zenith[0]))
print "Computing A matrix for %s pol..."%p
sys.stdout.flush()
timer = time.time()
A[p] = np.empty((len(tlist)*len(ubls), 12*nside**2), dtype='complex64')
rotator = hpr.Rotator(coord=['G', 'C'])
for i in range(12*nside**2):
dec, ra = rotator(hpf.pix2ang(nside, i, nest=True))#gives theta phi
dec = np.pi/2 - dec
print "\r%.1f%% completed, %f minutes left"%(100.*float(i)/(12.*nside**2), (12.*nside**2-i)/(i+1)*(float(time.time()-timer)/60.)),
sys.stdout.flush()
A[p][:, i] = vs.calculate_pointsource_visibility(ra, dec, ubls, freq, beam_heal_equ = beam_heal_equ, tlist = tlist).flatten()
print "%f minutes used"%(float(time.time()-timer)/60.)
sys.stdout.flush()
A[p].tofile(A_filename)
def p2a(ipix):
return pix2ang(nside, ipix, nest=True, lonlat=True)
def main(name, ra, dec, perf, inclin, energy, suffix, start, stop, torigin, truepoint, errrad, exstart, exstop):
# Spacecraft data
pathFileScAll = "/disk/gamma/cta/store/takhsm/FermiData/spacecraft/mtakahas-AstroServer-00011-ft2-30s.fits"
print "===================="
# PSF histogram
file_perf = ROOT.TFile(perf, 'READ')
htg2_psf = file_perf.Get('psf_cth_q68_hist')
FIXED_PSF_ENERGY = energy
if FIXED_PSF_ENERGY<=0:
print 'Scaling is variable for energy'
else:
print 'Scaling is fixed for energy at', FIXED_PSF_ENERGY
FIXED_PSF_INCLIN = inclin
if FIXED_PSF_INCLIN<=0:
print 'Scaling is variable for inclination'
else:
print 'Scaling is fixed for inclination at', FIXED_PSF_INCLIN
# ON/OFF regions
nOff = 0;
# NHPSIDE_ON = 512
NHPSIDE_ON = 32
ANG_CUT = 5.
ANG_CUT_RAD = radians(5.)
aHpx_array = [find_pointon_healpxs(ra, dec, ANG_CUT, nhpside=NHPSIDE_ON)]
aCoordsRegion = [SkyCoord(ra, dec, unit="deg")]
aCoordsPix_array = []
aAreaPix_array = []
aAreaPix_sum = []
aStrRegion = []
str_lit_unit = []
for (iRegion, coordsRegion) in enumerate(aCoordsRegion):
if iRegion==0:
aStrRegion.append("ON")
else:
aStrRegion.append("OFF{0}".format(iRegion))
if truepoint==True:
aCoordsPix_array.append(coordsRegion)
aAreaPix_array.append(0)
print aCoordsPix_array[-1]
str_lit_unit.append('sec')
aAreaPix_sum.append(0)
else:
aCoordsPix_array.append([])
aAreaPix_array.append([])
for npix in aHpx_array[iRegion]:
aAngPix = hppf.pix2ang(NHPSIDE_ON, npix)
aCoordsPix_array[-1].append(SkyCoord(aAngPix[1], pi/2.-aAngPix[0], unit="rad"))
area_pix = hppf.nside2pixarea(NHPSIDE_ON)
aAreaPix_array[-1].append(area_pix)
str_lit_unit.append('sec sr')
print aCoordsPix_array[-1]
aAreaPix_sum.append(sum(aAreaPix_array[-1]))
print 'Solid angle =', aAreaPix_sum[-1], 'sr'
# Output objects
aFileToI = []
if suffix!="":
suffix = "_" + suffix
if truepoint==True:
suffix = suffix + "_TruePoint"
fileRoot = ROOT.TFile("Livetime_{0}_MET{1}-{2}{3}.root".format(name, int(start), int(stop), suffix), "update")
aHtgLt = []
NBIN_CTH = 50
EDGE_CTH_LOW = 0.0
EDGE_CTH_UP = 1.0
NBIN_ZEN = 180
EDGE_ZEN_LOW = 0
EDGE_ZEN_UP = 180
NBIN_ENE = htg2_psf.GetNbinsX()
EDGE_ENE_LOW = htg2_psf.GetXaxis().GetBinLowEdge(1)
EDGE_ENE_UP = htg2_psf.GetXaxis().GetBinUpEdge(htg2_psf.GetNbinsX())
if torigin==0:
torigin = start
tmin_htg = 239557417
tmax_htg = 536457605
for hRegion in range(nOff+1):
aHtgLt.append(ROOT.TH3D("htgLt_{0}".format(hRegion), "Livetime for {0} [{1}];Cos(Inclination angle);Zenith angle [deg];Time - {2} [sec]".format(name, str_lit_unit[hRegion], torigin), NBIN_CTH, EDGE_CTH_LOW, EDGE_CTH_UP, NBIN_ZEN, EDGE_ZEN_LOW, EDGE_ZEN_UP, max(10, int(tmax_htg-tmin_htg)/54000), tmin_htg, tmax_htg))#tPro, tPost))
# make_livetime_histogram(aHtgLt, nOff+1 ,pathFileScAll, start+torigin, stop+torigin, aFileToI, aCoordsPix_array, aAreaPix_array, torigin) !!!BUG!!!
make_livetime_histogram(aHtgLt, nOff+1 ,pathFileScAll, start, stop, aFileToI, aCoordsPix_array, aAreaPix_array, torigin, exstart, exstop)
aHtgLt_projYX = []
aHtgLt_scaled = []
print 'Making output products...'
fileRoot.cd()
for jR in range(nOff+1):
print 'Region', jR
aHtgLt[jR].Write()
aHtgLt_projYX.append(aHtgLt[jR].Project3D("yx"))
aHtgLt_projYX[jR].Write()
if truepoint==False:
aHtgLt_scaled.append(ROOT.TH3D('{0}_scaled'.format(aHtgLt[jR].GetName()), '{0} scaled;{1};{2};log_{{10}}Energy [MeV]'.format(aHtgLt[jR].GetTitle(), aHtgLt_projYX[jR].GetXaxis().GetTitle(), aHtgLt_projYX[jR].GetYaxis().GetTitle()), NBIN_CTH, EDGE_CTH_LOW, EDGE_CTH_UP, NBIN_ZEN, EDGE_ZEN_LOW, EDGE_ZEN_UP, NBIN_ENE, EDGE_ENE_LOW, EDGE_ENE_UP))
for iz in range(1, 1+NBIN_ENE):
print ' Energy {0} - {1}'.format(aHtgLt_scaled[-1].GetZaxis().GetBinLowEdge(iz), aHtgLt_scaled[-1].GetZaxis().GetBinUpEdge(iz))
if FIXED_PSF_ENERGY<=0:
nbin_ene_psf = htg2_psf.GetXaxis().FindBin(aHtgLt_scaled[-1].GetZaxis().GetBinCenter(iz))
else:
nbin_ene_psf = htg2_psf.GetXaxis().FindBin(FIXED_PSF_ENERGY)
for ix in range(1, 1+NBIN_CTH):
if FIXED_PSF_INCLIN<=0:
nbin_inc_psf = htg2_psf.GetYaxis().FindBin(aHtgLt_scaled[-1].GetXaxis().GetBinCenter(ix))
else:
nbin_inc_psf = htg2_psf.GetYaxis().FindBin(FIXED_PSF_INCLIN)
psf_cut_rad = radians(htg2_psf.GetBinContent(nbin_ene_psf, nbin_inc_psf) + errrad)
area_ratio = 2.*pi*(1.0-cos(psf_cut_rad)) / aAreaPix_sum[jR]
print ' Inclination {0} - {1} : Scaling factor = {2}'.format(aHtgLt_scaled[-1].GetXaxis().GetBinLowEdge(ix), aHtgLt_scaled[-1].GetXaxis().GetBinUpEdge(ix), area_ratio)
for iy in range(1, 1+NBIN_ZEN):
aHtgLt_scaled[-1].SetBinContent(ix, iy, iz, aHtgLt_projYX[jR].GetBinContent(ix, iy)*area_ratio)
aHtgLt_scaled[-1].Write()
print 'Livetime calculation finished.'
nside = min(nside, 512)
L = nside*3 - 1
print "Using nside = %i for GSM."%nside,
sys.stdout.flush()
if nside not in GSMs:
print "Loading..."
sys.stdout.flush()
pcas = [hp.fitsfunc.read_map(datadir + '/gsm%i.fits'%(i+1) + str(nside), verbose=False) for i in range(3)]
print "done.",
sys.stdout.flush()
####rotate sky map and get alm
print "Rotating GSM",
sys.stdout.flush()
GSMs[nside] = np.zeros((3,12*nside**2),'float')
for i in range(12*nside**2):
ang = g2e_rotator(hpf.pix2ang(nside,i))
for j in range(3):
GSMs[nside][j,i] = hpf.get_interp_val(pcas[j], ang[0], ang[1])
print "Done."
gsm_weights = gsm_weights_f(np.log(freqs[f]))
print "GSM weights:", gsm_weights
sys.stdout.flush()
gsm = gsm_weights[0]*(gsm_weights[1]*GSMs[nside][0] + gsm_weights[2]*GSMs[nside][1] + gsm_weights[3]*GSMs[nside][2])
alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(gsm), 3 * nside - 1)
result = vs.calculate_visibility(sv.expand_real_alm(alm), d=ubl, freq=freqs[f], nt=nt, L = 3*nside-1, verbose = True)
result.astype('complex64').tofile(opdir+'/Visibilties_for_%i_south_%i_east_0_up_%s%s_pol_%.1f_MHz_%i_step.bin'%(unit_ubl[0],unit_ubl[1],pol,pol,freqs[f],nt))
print "Time taken %.4f"%(float((time.time()-timer)/60.))
#_
#__ _ ____ __ __ _| |_ __
#/ _` (_-< ' \ / _` | | ' \
#\__, /__/_|_|_| \__,_|_|_|_|_|
#|___/
#create sky map alm
pca1 = hp.fitsfunc.read_map('/home/eric/Dropbox/MIT/UROP/simulate_visibilities/GSM_32/gsm1.fits32')
pca2 = hp.fitsfunc.read_map('/home/eric/Dropbox/MIT/UROP/simulate_visibilities/GSM_32/gsm2.fits32')
pca3 = hp.fitsfunc.read_map('/home/eric/Dropbox/MIT/UROP/simulate_visibilities/GSM_32/gsm3.fits32')
gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3)
nside=32
equatorial_GSM = np.zeros(12*nside**2,'float')
#rotate sky map
for i in range(12*nside**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i))
pixindex, weight = hpf.get_neighbours(nside,ang[0],ang[1])
for pix in range(len(pixindex)):
equatorial_GSM[i] += weight[pix]*gsm[pixindex[pix]]
almlist = hp.sphtfunc.map2alm(equatorial_GSM,iter=10)
alm={}
for l in range(96):
for mm in range(-l,l+1):
if mm >= 0:
alm[(l,mm)] = (1.0j)**mm*almlist[hp.sphtfunc.Alm.getidx(nside*3-1,l,abs(mm))]
if mm < 0:
alm[(l,mm)] = np.conj((1.0j)**mm*almlist[hp.sphtfunc.Alm.getidx(nside*3-1,l,abs(mm))])
#set frequency and baseline vector
beam_healpix = abs(local_beam(freq)[0]) ** 2 + abs(local_beam(freq)[1]) ** 2
elif p == 'y':
beam_healpix = abs(local_beam(freq)[2]) ** 2 + abs(local_beam(freq)[3]) ** 2
# hpv.mollview(beam_healpix, title='beam %s'%p)
# plt.show()
vs = sv.Visibility_Simulator()
vs.initial_zenith = np.array([0, lat_degree * np.pi / 180]) # self.zenithequ
beam_heal_equ = np.array(
sv.rotate_healpixmap(beam_healpix, 0, np.pi / 2 - vs.initial_zenith[1], vs.initial_zenith[0]))
print "Computing A matrix for %s pol..." % p
sys.stdout.flush()
timer = time.time()
A[p] = np.empty((len(tlist) * len(ubls), 12 * nside_beamweight ** 2), dtype='complex64')
for i in range(12 * nside_beamweight ** 2):
dec, ra = hpf.pix2ang(nside_beamweight, i) # gives theta phi
dec = np.pi / 2 - dec
print "\r%.1f%% completed, %f minutes left" % (100. * float(i) / (12. * nside_beamweight ** 2),
(12. * nside_beamweight ** 2 - i) / (i + 1) * (
float(time.time() - timer) / 60.)),
sys.stdout.flush()
A[p][:, i] = np.array(
[vs.calculate_pointsource_visibility(ra, dec, d, freq, beam_heal_equ=beam_heal_equ, tlist=tlist) for d
in ubls]).flatten()
print "%f minutes used" % (float(time.time() - timer) / 60.)
sys.stdout.flush()
A[p].tofile(A_path)
A[p] = A[p].reshape((len(ubls), len(tlist), 12 * nside_beamweight ** 2))[:, tmask].reshape(
(len(ubls) * len(tlist[tmask]), 12 * nside_beamweight ** 2))
beam_heal_equ = np.array(sv.rotate_healpixmap(beam_healpix, 0, np.pi/2 - vs.initial_zenith[1], vs.initial_zenith[0]))
#compute A matrix
A_filename = datadir + tag + '_%s%s_%i_%i.A'%(p, p, len(tlist)*len(ubls), 12*nside**2)
if os.path.isfile(A_filename) and not force_recompute:
print "Reading A matrix from %s"%A_filename
A[p] = np.fromfile(A_filename, dtype='complex64').reshape((len(tlist)*len(ubls), 12*nside**2))
else:
print "Computing A matrix for %s pol..."%p
timer = time.time()
A[p] = np.empty((len(tlist)*len(ubls), 12*nside**2), dtype='complex64')
for i in range(12*nside**2):
dec, ra = hpf.pix2ang(nside, i)#gives theta phi
dec = np.pi/2 - dec
print "\r%.1f%% completed, %f minutes left"%(100.*float(i)/(12.*nside**2), (12.*nside**2-i)/(i+1)*(float(time.time()-timer)/60.)),
sys.stdout.flush()
A[p][:, i] = np.array([vs.calculate_pointsource_visibility(ra, dec, d, freq, beam_heal_equ = beam_heal_equ, tlist = tlist) for d in ubls]).flatten()
print "%f minutes used"%(float(time.time()-timer)/60.)
A[p].tofile(A_filename)
#get Ni (1/variance) and data
var_filename = datadir + tag + '_%s%s_%i_%i.var'%(p, p, nt, nUBL)
Ni[p] = 1./np.fromfile(var_filename, dtype='float32').reshape((nt, nUBL)).transpose().flatten()
data_filename = datadir + tag + '_%s%s_%i_%i.dat'%(p, p, nt, nUBL)
data[p] = (np.fromfile(data_filename, dtype='complex64').reshape((nt, nUBL)).transpose().flatten()*1.e-26*(C/freq)**2/kB/(4*np.pi/(12*nside**2))).conjugate()#there's a conjugate convention difference
vs.initial_zenith = np.array([0, lat_degree*np.pi/180])#self.zenithequ
beam_heal_equ = np.array(sv.rotate_healpixmap(beam_healpix, 0, np.pi/2 - vs.initial_zenith[1], vs.initial_zenith[0]))
timer = time.time()
if all_ubl:
ubls = infoubl
else:
ubls = [ubl for ubl in infoubl if la.norm(ubl) < inclusion_thresh * (nside_target * 299.792458 / freq)]
print "%i UBLs to include"%len(ubls)
if len(tlist)*len(ubls) < 12*nside**2:
for i in range(5):
print 'Not enough degree of freedom! %i*%i<%i.'%(len(tlist), len(ubls), 12*nside**2)
A = np.empty((len(tlist)*len(ubls), nps), dtype='complex64')
for i in range(nps):
ra, dec = point_sources[i]
theta = np.pi/2 - dec
phi = ra
theta_heal, phi_heal = hpf.pix2ang(nside, hpf.ang2pix(nside, theta, phi))
A[:, i] = np.array([vs.calculate_pointsource_visibility(phi_heal, np.pi/2.-theta_heal, d, freq, beam_heal_equ = beam_heal_equ, tlist = tlist) for d in ubls]).flatten()
print float(time.time()-timer)/60.
if all_ubl:
A.tofile('/home/omniscope/data/GSM_data/AmatrixPS_allubl_nside%i_%iby%i_'%(nside, len(A), len(A[0])) + infofile.split('/')[-1])
else:
A.tofile('/home/omniscope/data/GSM_data/AmatrixPS_%iubl_nside%i_%iby%i_'%(len(ubls), nside, len(A), len(A[0])) + infofile.split('/')[-1])
#plt.show()
vs = sv.Visibility_Simulator()
vs.initial_zenith = np.array([0, lat_degree * np.pi / 180
]) #self.zenithequ
beam_heal_equ = np.array(
sv.rotate_healpixmap(beam_healpix, 0,
np.pi / 2 - vs.initial_zenith[1],
vs.initial_zenith[0]))
print "Computing A matrix for %s pol..." % p
sys.stdout.flush()
timer = time.time()
A[p] = np.empty((len(tlist) * len(ubls), 12 * nside_beamweight**2),
dtype='complex64')
for i in range(12 * nside_beamweight**2):
dec, ra = hpf.pix2ang(nside_beamweight, i) #gives theta phi
dec = np.pi / 2 - dec
print "\r%.1f%% completed, %f minutes left" % (
100. * float(i) / (12. * nside_beamweight**2),
(12. * nside_beamweight**2 - i) / (i + 1) *
(float(time.time() - timer) / 60.)),
sys.stdout.flush()
A[p][:, i] = np.array([
vs.calculate_pointsource_visibility(
ra, dec, d, freq, beam_heal_equ=beam_heal_equ, tlist=tlist)
for d in ubls
]).flatten()
print "%f minutes used" % (float(time.time() - timer) / 60.)
sys.stdout.flush()
#hp.mollview(pca2, title='first PCA')
#hp.mollview(pca3, title='first PCA')
#plt.show()
pca1 = hp.fitsfunc.read_map(
'/home/eric/Dropbox/MIT/UROP/simulate_visibilities/GSM_32/gsm1.fits64')
pca2 = hp.fitsfunc.read_map(
'/home/eric/Dropbox/MIT/UROP/simulate_visibilities/GSM_32/gsm2.fits64')
pca3 = hp.fitsfunc.read_map(
'/home/eric/Dropbox/MIT/UROP/simulate_visibilities/GSM_32/gsm3.fits64')
gsm = 422.952 * (0.307706 * pca1 - 0.281772 * pca2 + 0.0123976 * pca3)
nside = 64
equatorial_GSM = np.zeros(12 * nside**2, 'float')
#rotate sky map
for i in range(12 * nside**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside, i))
pixindex, weight = hpf.get_neighbours(nside, ang[0], ang[1])
for pix in range(len(pixindex)):
equatorial_GSM[i] += np.log(weight[pix] * gsm[pixindex[pix]])
almlist = hp.sphtfunc.map2alm(equatorial_GSM)
alm = {}
for l in range(96):
for mm in range(-l, l + 1):
alm[(l, mm)] = almlist[hp.sphtfunc.Alm.getidx(nside * 3 - 1, l,
abs(mm))]
hp.visufunc.mollview(equatorial_GSM)
plt.show()
########################### ########################### ###OVER ALL PARAMETERS ########################### ########################### mother_nside = 32 mother_npix = hpf.nside2npix(mother_nside) smoothing_fwhm = 10. * np.pi / 180. edge_width = 10. * np.pi / 180. # mask_name = 'herastrip' # pixel_mask = (hpf.pix2ang(mother_nside, range(mother_npix), nest=True)[0] > np.pi/2 + np.pi/9) & (hpf.pix2ang(mother_nside, range(mother_npix), nest=True)[0] < np.pi/2 + np.pi/4.5) mask_name = 'plane20deg' pixel_mask = np.abs(hpf.pix2ang(mother_nside, range(mother_npix), nest=True)[0] - np.pi / 2) > np.pi / 9 step = .2 remove_cmb = True show_plots = False data_file_name = '/mnt/data0/omniscope/polarized foregrounds/data_nside_%i_smooth_%.2E_edge_%.2E_rmvcmb_%i.npz'%(mother_nside, smoothing_fwhm, edge_width, remove_cmb) data_file = np.load(data_file_name) freqs = data_file['freqs'] exclude_freqs = [freq for freq in freqs if freq > 40.]#[60.8, 70, 93.5] idata = data_file['idata'] qudata = data_file['qdata'] + 1.j * data_file['udata']
if nside not in GSMs:
print "Loading..."
sys.stdout.flush()
pcas = [
hp.fitsfunc.read_map(datadir + '/gsm%i.fits' % (i + 1) +
str(nside),
verbose=False) for i in range(3)
]
print "done.",
sys.stdout.flush()
####rotate sky map and get alm
print "Rotating GSM",
sys.stdout.flush()
GSMs[nside] = np.zeros((3, 12 * nside**2), 'float')
for i in range(12 * nside**2):
ang = g2e_rotator(hpf.pix2ang(nside, i))
for j in range(3):
GSMs[nside][j, i] = hpf.get_interp_val(
pcas[j], ang[0], ang[1])
print "Done."
gsm_weights = gsm_weights_f(np.log(freqs[f]))
print "GSM weights:", gsm_weights
sys.stdout.flush()
gsm = gsm_weights[0] * (gsm_weights[1] * GSMs[nside][0] +
gsm_weights[2] * GSMs[nside][1] +
gsm_weights[3] * GSMs[nside][2])
alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(gsm), 3 * nside - 1)
result = vs.calculate_visibility(sv.expand_real_alm(alm),
d=ubl,
freq=freqs[f],
pca2 = hp.fitsfunc.read_map(script_dir + '/../data/gsm2.fits' + str(nside_standard))
pca3 = hp.fitsfunc.read_map(script_dir + '/../data/gsm3.fits' + str(nside_standard))
components = np.loadtxt(script_dir + '/../data/components.dat')
scale_loglog = si.interp1d(np.log(components[:, 0]), np.log(components[:, 1]))
w1 = si.interp1d(components[:, 0], components[:, 2])
w2 = si.interp1d(components[:, 0], components[:, 3])
w3 = si.interp1d(components[:, 0], components[:, 4])
gsm_standard = np.exp(scale_loglog(np.log(freq))) * (w1(freq) * pca1 + w2(freq) * pca2 + w3(freq) * pca3)
# rotate sky map and converts to nest
equatorial_GSM_standard = np.zeros(12 * nside_standard ** 2, 'float')
print "Rotating GSM_standard and converts to nest...",
sys.stdout.flush()
equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot(sv.epoch_transmatrix(2000, stdtime=2013.58))
ang0, ang1 = hp.rotator.rotateDirection(equ2013_to_gal_matrix,
hpf.pix2ang(nside_standard, range(12 * nside_standard ** 2), nest=True))
equatorial_GSM_standard = hpf.get_interp_val(gsm_standard, ang0, ang1)
print "done."
sys.stdout.flush()
nside_distribution = np.zeros(12 * nside_standard ** 2)
final_index = np.zeros(12 * nside_standard ** 2, dtype=int)
thetas, phis, sizes = [], [], []
abs_thresh = np.mean(equatorial_GSM_standard) * thresh
pixelize(equatorial_GSM_standard, nside_distribution, nside_standard, nside_start, abs_thresh,
final_index, thetas, phis, sizes)
npix = len(thetas)
valid_pix_mask = hpf.get_interp_val(equatorial_GSM_standard, thetas, phis, nest=True) > valid_pix_thresh * max(equatorial_GSM_standard)
valid_npix = np.sum(valid_pix_mask)
print '>>>>>>VALID NPIX =', valid_npix
ubl for ubl in infoubl
if la.norm(ubl) < inclusion_thresh * (nside_target * 299.792458 / freq)
]
print "%i UBLs to include" % len(ubls)
if len(tlist) * len(ubls) < 12 * nside**2:
for i in range(5):
print 'Not enough degree of freedom! %i*%i<%i.' % (
len(tlist), len(ubls), 12 * nside**2)
A = np.empty((len(tlist) * len(ubls), nps), dtype='complex64')
for i in range(nps):
ra, dec = point_sources[i]
theta = np.pi / 2 - dec
phi = ra
theta_heal, phi_heal = hpf.pix2ang(nside, hpf.ang2pix(nside, theta, phi))
A[:, i] = np.array([
vs.calculate_pointsource_visibility(phi_heal,
np.pi / 2. - theta_heal,
d,
freq,
beam_heal_equ=beam_heal_equ,
tlist=tlist) for d in ubls
]).flatten()
print float(time.time() - timer) / 60.
if all_ubl:
A.tofile('/home/omniscope/data/GSM_data/AmatrixPS_allubl_nside%i_%iby%i_' %
(nside, len(A), len(A[0])) + infofile.split('/')[-1])
else:
A.tofile('/home/omniscope/data/GSM_data/AmatrixPS_%iubl_nside%i_%iby%i_' %
A = np.fromfile(A_filename, dtype='float32').reshape((len(data), npix))
print "Memory usage: %.3fMB"%(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)
#simulate data using GSM
nside_standard = nside
pca1 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm1.fits' + str(nside_standard))
pca2 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm2.fits' + str(nside_standard))
pca3 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm3.fits' + str(nside_standard))
gsm_standard = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3)
equatorial_GSM_standard = np.zeros(12*nside_standard**2,'float')
#rotate sky map
print "Rotating GSM_standard...",
sys.stdout.flush()
#print hp.rotator.Rotator(coord='cg').mat
for i in range(12*nside_standard**2):
ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside_standard,i))
equatorial_GSM_standard[i] = hpf.get_interp_val(gsm_standard, ang[0], ang[1])
print "done."
sys.stdout.flush()
print "Simulating GSM data...",
sys.stdout.flush()
sim_data = np.array([A[i].dot(equatorial_GSM_standard[pix_mask]) for i in range(len(A))]) + np.random.randn(len(data))/Ni**.5
print "done."
sys.stdout.flush()
#compute At.y
print "Computing At.y...",
sys.stdout.flush()
qaz = Ni * data
Atdata = np.array([A[:, i].dot(qaz) for i in range(len(A[0]))])
A[p] = np.fromfile(A_filename, dtype='complex64').reshape((len(ubls), len(tlist), 12*nside**2))[:,tmask].reshape((len(ubls)*len(tlist[tmask]), 12*nside**2))
else:
#beam
beam_healpix = local_beam[p](freq)
#hpv.mollview(beam_healpix, title='beam %s'%p)
#plt.show()
vs = sv.Visibility_Simulator()
vs.initial_zenith = np.array([0, lat_degree*np.pi/180])#self.zenithequ
beam_heal_equ = np.array(sv.rotate_healpixmap(beam_healpix, 0, np.pi/2 - vs.initial_zenith[1], vs.initial_zenith[0]))
print "Computing A matrix for %s pol..."%p
sys.stdout.flush()
timer = time.time()
A[p] = np.empty((len(tlist)*len(ubls), 12*nside**2), dtype='complex64')
for i in range(12*nside**2):
dec, ra = hpf.pix2ang(nside, i)#gives theta phi
dec = np.pi/2 - dec
print "\r%.1f%% completed, %f minutes left"%(100.*float(i)/(12.*nside**2), (12.*nside**2-i)/(i+1)*(float(time.time()-timer)/60.)),
sys.stdout.flush()
A[p][:, i] = np.array([vs.calculate_pointsource_visibility(ra, dec, d, freq, beam_heal_equ = beam_heal_equ, tlist = tlist) for d in ubls]).flatten()
print "%f minutes used"%(float(time.time()-timer)/60.)
sys.stdout.flush()
A[p].tofile(A_filename)
A[p] = A[p].reshape((len(ubls), len(tlist), 12*nside**2))[:,tmask].reshape((len(ubls)*len(tlist[tmask]), 12*nside**2))
#get Ni (1/variance) and data
var_filename = datadir + tag + '_%s%s_%i_%i.var'%(p, p, nt, nUBL)
Ni[p] = 1./(np.fromfile(var_filename, dtype='float32').reshape((nt, nUBL))[tmask].transpose().flatten() * (1.e-26*(C/freq)**2/kB/(4*np.pi/(12*nside**2)))**2)
data_filename = datadir + tag + '_%s%s_%i_%i'%(p, p, nt, nUBL) + datatag
import glob, sys
import numpy as np
import healpy as hp
import healpy.pixelfunc as hpf
import healpy.visufunc as hpv
import scipy.interpolate as interp
import simulate_visibilities.simulate_visibilities as sv
import time
import matplotlib.pyplot as plt
nside_standard = 512
#out put Ephi, Ealpha in healpix ring convention
heal_thetas, heal_phis = hpf.pix2ang(nside_standard, range(12*nside_standard**2))
pos_alpha_mask = heal_thetas < np.pi/2
unique_heal_thetas = np.unique(heal_thetas[pos_alpha_mask])
#The 1st column is the azimuthal angle "phi", the second column is the elevation angle "alpha" (theta=pi/2-alpha, if you think of theta as the angle from the z-axis), and the only other relevant column is the 7th one - that's the linear beam strength (the 8th column is a 10log10 of the 7th, but it's not nearly as intuitive in representation).
#Then the 3-4th columns are the real and imaginary components of the electric field in the phi direction "E_phi" and the 5-6th columns are the real and imaginary components of the electric field in the alpha direction "E_alpha"
# print np.sum(pos_alpha_mask), len(pos_alpha_mask)
# plt.plot(pos_alpha_mask); plt.show()
##original script
for pol in ['x', 'y']:
result = np.zeros((9, 12*nside_standard**2, 2), dtype='complex64')
d = np.concatenate([np.loadtxt(f) for f in sorted(glob.glob('/home/omniscope/data/mwa_beam/mwa_*-*%s*'%pol))])
d.shape = (9, 180, 45, 8)
def _catalog_to_cells_neighbor(catalog, radius, order):
"""
Convert a catalog to a list of cells.
This is the original implementation of the `catalog_to_cells`
function which does not make use of the Healpy `query_disc` routine.
Note: this function uses a simple flood-filling approach and is
very slow, especially when used with a large radius for catalog objects
or a high resolution order.
"""
if not isinstance(radius, Quantity):
radius = radius * arcsecond
nside = 2**order
# Ensure catalog is in ICRS coordinates.
catalog = catalog.icrs
# Determine central cell for each catalog entry.
phi = catalog.ra.radian
theta = (pi / 2) - catalog.dec.radian
cells = np.unique(ang2pix(nside, theta, phi, nest=True))
# Iteratively consider the neighbors of cells within our
# catalog regions.
new_cells = cells
rejected = np.array((), dtype=np.int64)
while True:
# Find new valid neighboring cells which we didn't already
# consider.
neighbors = np.unique(
np.ravel(get_all_neighbours(nside, new_cells, nest=True)))
neighbors = np.extract([(x != -1) and (x not in cells) and
(x not in rejected)
for x in neighbors], neighbors)
# Get the coordinates of each of these neighbors and compare them
# to the catalog entries.
(theta, phi) = pix2ang(nside, neighbors, nest=True)
coords = SkyCoord(phi, (pi / 2) - theta, frame='icrs', unit='rad')
(idx, sep2d, dist3d) = coords.match_to_catalog_sky(catalog)
within_range = (sep2d < radius)
# If we didn't find any new cells within range,
# end the iterative process.
if not np.any(within_range):
break
new_cells = neighbors[within_range]
cells = np.concatenate((cells, new_cells))
rejected = np.concatenate(
(rejected, neighbors[np.logical_not(within_range)]))
return cells
sys.stdout.flush()
A[p] = np.fromfile(A_filename, dtype='complex64').reshape((len(ubls), len(tlist), 12*nside_beamweight**2))[:,tmask].reshape((len(ubls)*len(tlist[tmask]), 12*nside_beamweight**2))
else:
beam_healpix = np.fromfile(datadir + 'mwa_curtin_beam_%s_nside%i_freq167.275_zenith_float32.dat'%(p, bnside), dtype='float32')
#hpv.mollview(beam_healpix, title='beam %s'%p)
#plt.show()
vs = sv.Visibility_Simulator()
vs.initial_zenith = np.array([0, lat_degree*np.pi/180])#self.zenithequ
beam_heal_equ = np.array(sv.rotate_healpixmap(beam_healpix, 0, np.pi/2 - vs.initial_zenith[1], vs.initial_zenith[0]))
print "Computing A matrix for %s pol..."%p
sys.stdout.flush()
timer = time.time()
A[p] = np.empty((len(tlist)*len(ubls), 12*nside_beamweight**2), dtype='complex64')
for i in range(12*nside_beamweight**2):
dec, ra = hpf.pix2ang(nside_beamweight, i)#gives theta phi
dec = np.pi/2 - dec
print "\r%.1f%% completed, %f minutes left"%(100.*float(i)/(12.*nside_beamweight**2), (12.*nside_beamweight**2-i)/(i+1)*(float(time.time()-timer)/60.)),
sys.stdout.flush()
A[p][:, i] = np.array([vs.calculate_pointsource_visibility(ra, dec, d, freq, beam_heal_equ = beam_heal_equ, tlist = tlist) for d in ubls]).flatten()
print "%f minutes used"%(float(time.time()-timer)/60.)
sys.stdout.flush()
A[p].tofile(A_filename)
A[p] = A[p].reshape((len(ubls), len(tlist), 12*nside_beamweight**2))[:,tmask].reshape((len(ubls)*len(tlist[tmask]), 12*nside_beamweight**2))
####################################################
###beam weights using an equal pixel A matrix######
#################################################
#compute A matrix
A_filename = datadir + tag + '_%s%s_%i_%i.A' % (p, p, len(tlist) *
len(ubls), 12 * nside**2)
if os.path.isfile(A_filename) and not force_recompute:
print "Reading A matrix from %s" % A_filename
A[p] = np.fromfile(A_filename, dtype='complex64').reshape(
(len(tlist) * len(ubls), 12 * nside**2))
else:
print "Computing A matrix for %s pol..." % p
timer = time.time()
A[p] = np.empty((len(tlist) * len(ubls), 12 * nside**2),
dtype='complex64')
for i in range(12 * nside**2):
dec, ra = hpf.pix2ang(nside, i) #gives theta phi
dec = np.pi / 2 - dec
print "\r%.1f%% completed, %f minutes left" % (
100. * float(i) / (12. * nside**2), (12. * nside**2 - i) /
(i + 1) * (float(time.time() - timer) / 60.)),
sys.stdout.flush()
A[p][:, i] = np.array([
vs.calculate_pointsource_visibility(
ra, dec, d, freq, beam_heal_equ=beam_heal_equ, tlist=tlist)
for d in ubls
]).flatten()
print "%f minutes used" % (float(time.time() - timer) / 60.)
A[p].tofile(A_filename)
