def get_circle(ra, dec, rad_deg, n=100):
th = np.linspace(np.radians(rad_deg), np.radians(rad_deg), n)
phi = np.linspace(0, 2 * np.pi, n)
v = Vector3D.createThetaPhi(th, phi)
v.rotatey(np.pi / 2. - np.radians(dec))
v.rotatez(np.radians(ra))
return np.degrees(v.lon()), np.degrees(v.lat())
def __init__(self, data):
self.__dict__.update(data)
self._names_dict = {}
self._cel_vec = Vector3D.createLatLon(np.radians(self.DEJ2000),
np.radians(self.RAJ2000))
self._gal_vec = Vector3D.createLatLon(np.radians(self.GLAT),
np.radians(self.GLON))
#[np.sin(theta)*np.cos(phi),
# np.sin(theta)*np.sin(phi),
# np.cos(theta)]
self._names = []
for k in Catalog.src_name_cols:
if not k in self.__dict__: continue
name = self.__dict__[k].strip()
if name != '': self._names.append(name)
self._names_dict[k] = name
def load_photons(self, ft1file):
hdulist = pyfits.open(ft1file)
evhdu = hdulist['EVENTS']
if self.config['max_events'] is not None:
table = evhdu.data[0:self.config['max_events']]
else:
table = evhdu.data
msk = table.field('ZENITH_ANGLE') < self.config['zmax']
if not self.config['event_class_id'] is None:
event_class = bitarray_to_int(table.field('EVENT_CLASS'), True)
msk &= (event_class &
((0x1) << int(self.config['event_class_id'])) > 0)
if not self.config['event_type_id'] is None:
event_type = bitarray_to_int(table.field('EVENT_TYPE'), True)
msk &= (event_type &
((0x1) << int(self.config['event_type_id'])) > 0)
table = table[msk]
if self.config['erange'] is not None:
erange = [float(t) for t in self.config['erange'].split('/')]
msk = ((np.log10(table.field('ENERGY')) > erange[0]) &
(np.log10(table.field('ENERGY')) < erange[1]))
table = table[msk]
if self.config['conversion_type'] is not None:
if self.config['conversion_type'] == 'front':
msk = table.field('CONVERSION_TYPE') == 0
else:
msk = table.field('CONVERSION_TYPE') == 1
table = table[msk]
if self.config['phase_selection'] is not None:
msk = table.field('PULSE_PHASE') < 0
phases = self.config['phase_selection'].split(',')
for p in phases:
(plo, phi) = p.split('/')
msk |= ((table.field('PULSE_PHASE') > float(plo)) &
(table.field('PULSE_PHASE') < float(phi)))
table = table[msk]
nevent = len(table)
print 'Loading ', ft1file, ' nevent: ', nevent
pd = self._photon_data
for isrc, (src_ra,
src_dec) in enumerate(zip(self.src_ra_deg,
self.src_dec_deg)):
vsrc = Vector3D.createLatLon(np.radians(src_dec),
np.radians(src_ra))
msk = ((table.field('DEC') > (src_dec - self.config['max_dist'])) &
(table.field('DEC') < (src_dec + self.config['max_dist'])))
table_src = table[msk]
vra = np.array(table_src.field('RA'), dtype=float)
vdec = np.array(table_src.field('DEC'), dtype=float)
vptz_ra = np.array(table_src.field('PtRaz'), dtype=float)
vptz_dec = np.array(table_src.field('PtDecz'), dtype=float)
dth = separation_angle(self.src_radec[isrc][0],
self.src_radec[isrc][1], np.radians(vra),
np.radians(vdec))
print 'Applying distance max'
msk = dth < np.radians(self.config['max_dist'])
table_src = table_src[msk]
vra = vra[msk]
vdec = vdec[msk]
vptz_ra = vptz_ra[msk]
vptz_dec = vptz_dec[msk]
veq = Vector3D.createLatLon(np.radians(vdec), np.radians(vra))
eptz = Vector3D.createLatLon(np.radians(vptz_dec),
np.radians(vptz_ra))
# True incidenge angle from source
src_theta = vsrc.separation(eptz)
print 'Getting projected direction'
vp = veq.project2d(vsrc)
vx = np.degrees(vp.theta() * np.sin(vp.phi()))
vy = -np.degrees(vp.theta() * np.cos(vp.phi()))
vptz = eptz.project2d(vsrc)
vp2 = copy.deepcopy(vp)
vp2.rotatez(-vptz.phi())
print 'Getting projected direction2'
vx2 = np.degrees(vp2.theta() * np.sin(vp2.phi()))
vy2 = -np.degrees(vp2.theta() * np.cos(vp2.phi()))
# import matplotlib.pyplot as plt
# print vp.theta()[:10]
# print vp2.theta()[:10]
# print np.sqrt(vx**2+vy**2)[:10]
# print np.sqrt(vx2**2+vy2**2)[:10]
# plt.figure()
# plt.plot(vx2,vy2,marker='o',linestyle='None')
# plt.gca().set_xlim(-80,80)
# plt.gca().set_ylim(-80,80)
# plt.figure()
# plt.plot(vx,vy,marker='o',linestyle='None')
# plt.show()
# vx2 = np.degrees(vp.theta()*np.sin(vp.phi()))
# vy2 = -np.degrees(vp.theta()*np.cos(vp.phi()))
src_index = np.zeros(len(table_src), dtype=int)
src_index[:] = isrc
src_phase = np.zeros(len(table_src))
if 'PULSE_PHASE' in evhdu.columns.names:
src_phase = table_src.field('PULSE_PHASE')
psf_core = np.zeros(len(table_src))
if 'CTBCORE' in evhdu.columns.names:
psf_core = list(table_src.field('CTBCORE'))
event_type = np.zeros(len(table_src), dtype='int')
if 'EVENT_TYPE' in evhdu.columns.names:
event_type = bitarray_to_int(table_src.field('EVENT_TYPE'),
True)
event_class = bitarray_to_int(table_src.field('EVENT_CLASS'), True)
pd.append('psfcore', psf_core)
pd.append('time', table_src.field('TIME'))
pd.append('ra', table_src.field('RA'))
pd.append('dec', table_src.field('DEC'))
pd.append('delta_ra', vx)
pd.append('delta_dec', vy)
pd.append('delta_phi', vx2)
pd.append('delta_theta', vy2)
pd.append('energy', np.log10(table_src.field('ENERGY')))
pd.append('dtheta', dth[msk])
pd.append('event_class', event_class)
pd.append('event_type', event_type)
pd.append('conversion_type',
table_src.field('CONVERSION_TYPE').astype('int'))
pd.append('src_index', src_index)
pd.append('phase', src_phase)
pd.append('cth', np.cos(src_theta))
# pd.append('cth',np.cos(np.radians(table_src.field('THETA'))))
# costheta2 = np.cos(src_theta)
# costheta = np.cos(np.radians(table_src.field('THETA')))
if self._phist is not None:
import skymaps
cthv = []
for k in range(len(table_src)):
sd = skymaps.SkyDir(src_ra, src_dec)
pi = self._phist(table_src.field('TIME')[k])
cth = np.cos(pi.zAxis().difference(sd))
print k, pd['energy'][k], cth, np.cos(
theta3[k]), costheta[k]
cthv.append(cth)
pd.append('cth', cthv)
print 'Finished'
# print 'Loaded ', len(self.dtheta), ' events'
hdulist.close()
jint.compute()
sys.exit(0)
#z = np.ones(shape=(360,360))
#hc = Histogram2D(theta_edges,phi_edges)
for i0, th in enumerate(theta):
jtot = integrate(lambda t: jspline(t) * np.sin(t),
np.radians(theta_edges[i0]),
np.radians(theta_edges[i0 + 1]), 100)
# jval = jspline(np.radians(th))*costh_width[i0]
v = Vector3D.createThetaPhi(np.radians(th), np.radians(phi))
v.rotate(yaxis)
lat = np.degrees(v.lat())
lon = np.degrees(v.phi())
src_msk = len(lat) * [True]
if not sources is None:
for k in range(len(v.lat())):
p = Vector3D(v._x[:, k])
sep = np.degrees(p.separation(sources))
imin = np.argmin(sep)
minsep = sep[imin]
def add_roi_msk(self,lon,lat,rad,invert=False,coordsys='cel'):
v0 = Vector3D.createLatLon(np.radians(self._pix_lat),
np.radians(self._pix_lon))
if self._axes[0]._coordsys == 'gal' and coordsys=='cel':
lon,lat = eq2gal(lon,lat)
elif self._axes[0]._coordsys == 'cel' and coordsys=='gal':
lon,lat = gal2eq(lon,lat)
v1 = Vector3D.createLatLon(np.radians(lat),np.radians(lon))
dist = np.degrees(v0.separation(v1))
dist = dist.reshape(self._counts.shape[:2])
if not invert: self._roi_msk[dist<rad] = True
else: self._roi_msk[dist>rad] = True
def get_circle(ra,dec,rad_deg,n=100):
th = np.linspace(np.radians(rad_deg),
np.radians(rad_deg),n)
phi = np.linspace(0,2*np.pi,n)
v = Vector3D.createThetaPhi(th,phi)
v.rotatey(np.pi/2.-np.radians(dec))
v.rotatez(np.radians(ra))
return np.degrees(v.lon()), np.degrees(v.lat())
def __init__(self,data):
self.__dict__.update(data)
self._names_dict = {}
self._cel_vec = Vector3D.createLatLon(np.radians(self.DEJ2000),
np.radians(self.RAJ2000))
self._gal_vec = Vector3D.createLatLon(np.radians(self.GLAT),
np.radians(self.GLON))
#[np.sin(theta)*np.cos(phi),
# np.sin(theta)*np.sin(phi),
# np.cos(theta)]
self._names = []
for k in Catalog.src_name_cols:
if not k in self.__dict__: continue
name = self.__dict__[k].strip()
if name != '': self._names.append(name)
self._names_dict[k] = name
def load_photons(self,ft1file):
hdulist = pyfits.open(ft1file)
evhdu = hdulist['EVENTS']
if self.config['max_events'] is not None:
table = evhdu.data[0:self.config['max_events']]
else:
table = evhdu.data
msk = table.field('ZENITH_ANGLE')<self.config['zmax']
if not self.config['event_class_id'] is None:
event_class = bitarray_to_int(table.field('EVENT_CLASS'),True)
msk &= (event_class&((0x1)<<int(self.config['event_class_id']))>0)
if not self.config['event_type_id'] is None:
event_type = bitarray_to_int(table.field('EVENT_TYPE'),True)
msk &= (event_type&((0x1)<<int(self.config['event_type_id']))>0)
table = table[msk]
if self.config['erange'] is not None:
erange = [float(t) for t in self.config['erange'].split('/')]
msk = ((np.log10(table.field('ENERGY')) > erange[0]) &
(np.log10(table.field('ENERGY')) < erange[1]))
table = table[msk]
if self.config['conversion_type'] is not None:
if self.config['conversion_type'] == 'front':
msk = table.field('CONVERSION_TYPE') == 0
else:
msk = table.field('CONVERSION_TYPE') == 1
table = table[msk]
if self.config['phase_selection'] is not None:
msk = table.field('PULSE_PHASE')<0
phases = self.config['phase_selection'].split(',')
for p in phases:
(plo,phi) = p.split('/')
msk |= ((table.field('PULSE_PHASE')>float(plo)) &
(table.field('PULSE_PHASE')<float(phi)))
table = table[msk]
nevent = len(table)
print 'Loading ', ft1file, ' nevent: ', nevent
pd = self._photon_data
for isrc, (src_ra,src_dec) in enumerate(zip(self.src_ra_deg,self.src_dec_deg)):
vsrc = Vector3D.createLatLon(np.radians(src_dec),
np.radians(src_ra))
if self.src_names[isrc] != 'ridge':
msk = ((table.field('DEC')>(src_dec-self.config['max_dist'])) &
(table.field('DEC')<(src_dec+self.config['max_dist'])))
table_src = table[msk]
vra = np.array(table_src.field('RA'),dtype=float)
vdec = np.array(table_src.field('DEC'),dtype=float)
vptz_ra = np.array(table_src.field('PtRaz'),dtype=float)
vptz_dec = np.array(table_src.field('PtDecz'),dtype=float)
dth = separation_angle(self.src_radec[isrc][0],
self.src_radec[isrc][1],
np.radians(vra),
np.radians(vdec))
msk = dth < np.radians(self.config['max_dist'])
table_src = table_src[msk]
vra = vra[msk]
vdec = vdec[msk]
vptz_ra = vptz_ra[msk]
vptz_dec = vptz_dec[msk]
veq = Vector3D.createLatLon(np.radians(vdec),
np.radians(vra))
eptz = Vector3D.createLatLon(np.radians(vptz_dec),
np.radians(vptz_ra))
# True incidenge angle from source
src_theta = vsrc.separation(eptz)
vp = veq.project2d(vsrc)
vx = np.degrees(vp.theta()*np.sin(vp.phi()))
vy = -np.degrees(vp.theta()*np.cos(vp.phi()))
vptz = eptz.project2d(vsrc)
vp2 = copy.deepcopy(vp)
vp2.rotatez(-vptz.phi())
vx2 = np.degrees(vp2.theta()*np.sin(vp2.phi()))
vy2 = -np.degrees(vp2.theta()*np.cos(vp2.phi()))
costheta = np.cos(src_theta)
dth = dth[msk]
else:
table_src = table
costheta = np.cos(np.radians(table_src.field('THETA')))
vx = np.zeros(len(costheta))
vy = np.zeros(len(costheta))
vx2 = np.zeros(len(costheta))
vy2 = np.zeros(len(costheta))
dth = np.zeros(len(costheta))
src_index = np.zeros(len(table_src),dtype=int)
src_index[:] = isrc
src_phase = np.zeros(len(table_src))
if 'PULSE_PHASE' in evhdu.columns.names:
src_phase = table_src.field('PULSE_PHASE')
psf_core = np.zeros(len(table_src))
if 'CTBCORE' in evhdu.columns.names:
psf_core = list(table_src.field('CTBCORE'))
event_type = np.zeros(len(table_src),dtype='int')
if 'EVENT_TYPE' in evhdu.columns.names:
event_type = bitarray_to_int(table_src.field('EVENT_TYPE'),True)
event_class = bitarray_to_int(table_src.field('EVENT_CLASS'),True)
pd.append('psfcore',psf_core)
pd.append('time',table_src.field('TIME'))
pd.append('ra',table_src.field('RA'))
pd.append('dec',table_src.field('DEC'))
pd.append('glon',table_src.field('L'))
pd.append('glat',table_src.field('B'))
pd.append('delta_ra',vx)
pd.append('delta_dec',vy)
pd.append('delta_phi',vx2)
pd.append('delta_theta',vy2)
pd.append('energy',np.log10(table_src.field('ENERGY')))
pd.append('dtheta',dth)
pd.append('event_class',event_class)
pd.append('event_type',event_type)
pd.append('conversion_type',
table_src.field('CONVERSION_TYPE').astype('int'))
pd.append('src_index',src_index)
pd.append('phase',src_phase)
pd.append('cth',costheta)
# pd.append('cth',np.cos(np.radians(table_src.field('THETA'))))
# costheta2 = np.cos(src_theta)
# costheta = np.cos(np.radians(table_src.field('THETA')))
if self._phist is not None:
import skymaps
cthv = []
for k in range(len(table_src)):
sd = skymaps.SkyDir(src_ra,src_dec)
pi = self._phist(table_src.field('TIME')[k])
cth = np.cos(pi.zAxis().difference(sd))
print k, pd['energy'][k], cth, np.cos(theta3[k]), costheta[k]
cthv.append(cth)
pd.append('cth',cthv)
print 'Finished'
# print 'Loaded ', len(self.dtheta), ' events'
hdulist.close()
jint.compute()
sys.exit(0)
#z = np.ones(shape=(360,360))
#hc = Histogram2D(theta_edges,phi_edges)
for i0, th in enumerate(theta):
jtot = integrate(lambda t: jspline(t)*np.sin(t),
np.radians(theta_edges[i0]),
np.radians(theta_edges[i0+1]),100)
# jval = jspline(np.radians(th))*costh_width[i0]
v = Vector3D.createThetaPhi(np.radians(th),np.radians(phi))
v.rotate(yaxis)
lat = np.degrees(v.lat())
lon = np.degrees(v.phi())
src_msk = len(lat)*[True]
if not sources is None:
for k in range(len(v.lat())):
p = Vector3D(v._x[:,k])
sep = np.degrees(p.separation(sources))
imin = np.argmin(sep)
minsep = sep[imin]
def load_photons(self,fname,ft2file=None):
if ft2file is not None: setFT2File(ft2file)
hdulist = pyfits.open(fname)
# hdulist.info()
# print hdulist[1].columns.names
if self.max_events is not None:
table = hdulist[1].data[0:self.max_events]
else:
table = hdulist[1].data
msk = table.field('ZENITH_ANGLE')<self.zenith_cut
if not self.event_class_id is None:
event_class = bitarray_to_int(table.field('EVENT_CLASS'),True)
msk &= (event_class&((0x1)<<int(self.event_class_id))>0)
if not self.event_type_id is None:
event_type = bitarray_to_int(table.field('EVENT_TYPE'),True)
msk &= (event_type&((0x1)<<int(self.event_type_id))>0)
table = table[msk]
if self.erange is not None:
erange = [float(t) for t in self.erange.split('/')]
msk = ((np.log10(table.field('ENERGY')) > erange[0]) &
(np.log10(table.field('ENERGY')) < erange[1]))
table = table[msk]
if self.conversion_type is not None:
if self.conversion_type == 'front':
msk = table.field('CONVERSION_TYPE') == 0
else:
msk = table.field('CONVERSION_TYPE') == 1
table = table[msk]
if self.phase_selection is not None:
msk = table.field('PULSE_PHASE')<0
phases = self.phase_selection.split(',')
for p in phases:
(plo,phi) = p.split('/')
msk |= ((table.field('PULSE_PHASE')>float(plo)) &
(table.field('PULSE_PHASE')<float(phi)))
table = table[msk]
nevent = len(table)
print 'Loading ', fname, ' nevent: ', nevent
pd = self._photon_data
for isrc, src in enumerate(self.srcs):
vsrc = Vector3D.createLatLon(np.radians(src.dec()),
np.radians(src.ra()))
# print 'Source ', isrc
msk = (table.field('DEC')>(src.dec()-np.degrees(self.max_dist))) & \
(table.field('DEC')<(src.dec()+np.degrees(self.max_dist)))
table_src = table[msk]
vra = np.array(table_src.field('RA'),dtype=float)
vdec = np.array(table_src.field('DEC'),dtype=float)
vptz_ra = np.array(table_src.field('PtRaz'),dtype=float)
vptz_dec = np.array(table_src.field('PtDecz'),dtype=float)
dth = separation_angle(self.src_radec[isrc][0],
self.src_radec[isrc][1],
np.radians(vra),
np.radians(vdec))
msk = dth < self.max_dist
table_src = table_src[msk]
vra = vra[msk]
vdec = vdec[msk]
vptz_ra = vptz_ra[msk]
vptz_dec = vptz_dec[msk]
veq = Vector3D.createLatLon(np.radians(vdec),
np.radians(vra))
eptz = Vector3D.createLatLon(np.radians(vptz_dec),
np.radians(vptz_ra))
vp = veq.project2d(vsrc)
vx = np.degrees(vp.theta()*np.sin(vp.phi()))
vy = -np.degrees(vp.theta()*np.cos(vp.phi()))
vptz = eptz.project2d(vsrc)
# print vptz.phi()
vp2 = copy.deepcopy(vp)
vp2.rotatez(-vptz.phi())
vx2 = np.degrees(vp2.theta()*np.sin(vp2.phi()))
vy2 = -np.degrees(vp2.theta()*np.cos(vp2.phi()))
# import matplotlib.pyplot as plt
# print vp.theta()[:10]
# print vp2.theta()[:10]
# print np.sqrt(vx**2+vy**2)[:10]
# print np.sqrt(vx2**2+vy2**2)[:10]
# plt.figure()
# plt.plot(vx2,vy2,marker='o',linestyle='None')
# plt.gca().set_xlim(-80,80)
# plt.gca().set_ylim(-80,80)
# plt.figure()
# plt.plot(vx,vy,marker='o',linestyle='None')
# plt.show()
# vx2 = np.degrees(vp.theta()*np.sin(vp.phi()))
# vy2 = -np.degrees(vp.theta()*np.cos(vp.phi()))
src_index = np.zeros(len(table_src),dtype=int)
src_index[:] = isrc
# src_redshift = np.zeros(len(table_src))
# src_redshift[:] = self.src_redshifts[isrc]
# self.redshift += list(src_redshift)
src_phase = np.zeros(len(table_src))
if 'PULSE_PHASE' in hdulist[1].columns.names:
src_phase = list(table_src.field('PULSE_PHASE'))
psf_core = np.zeros(len(table_src))
if 'CTBCORE' in hdulist[1].columns.names:
psf_core = list(table_src.field('CTBCORE'))
event_type = np.zeros(len(table_src),dtype='int')
if 'EVENT_TYPE' in hdulist[1].columns.names:
event_type = bitarray_to_int(table_src.field('EVENT_TYPE'),True)
event_class = bitarray_to_int(table_src.field('EVENT_CLASS'),True)
pd.append('psfcore',psf_core)
pd.append('time',list(table_src.field('TIME')))
pd.append('ra',list(table_src.field('RA')))
pd.append('dec',list(table_src.field('DEC')))
pd.append('delta_ra',list(vx))
pd.append('delta_dec',list(vy))
pd.append('delta_phi',list(vx2))
pd.append('delta_theta',list(vy2))
pd.append('energy',list(np.log10(table_src.field('ENERGY'))))
pd.append('dtheta',list(dth[msk]))
pd.append('event_class',list(event_class))
pd.append('event_type',list(event_type))
pd.append('conversion_type',
list(table_src.field('CONVERSION_TYPE').astype('int')))
pd.append('src_index',list(src_index))
pd.append('phase',list(src_phase))
cthv = []
for k in range(len(table_src)):
# event = table_src[k]
# ra = float(event.field('RA'))
# dec = float(event.field('DEC'))
# sd = skymaps.SkyDir(ra,dec)
# event = table_src[k]
# theta = float(event.field('THETA'))*deg2rad
# time = event.field('TIME')
if self._phist is not None:
pi = self._phist(table_src.field('TIME')[k])
cth = np.cos(pi.zAxis().difference(src))
cthv.append(cth)
pd.append('cth',cthv)
# print 'Loaded ', len(self.dtheta), ' events'
hdulist.close()
