def plot_frb_localization(ifrb, wcs, scale=1.):
# FRB localization
theta = ifrb.eellipse['theta']
aper = SkyEllipticalAperture(positions=ifrb.coord,
a=scale * ifrb.sig_a * units.arcsecond,
b=scale * ifrb.sig_b * units.arcsecond,
theta=theta * units.deg)
apermap = aper.to_pixel(wcs)
return apermap
def plot_ellipse_spetial_points(dic_bb,
angle,
box,
wcs,
bb,
chan,
ax=None,
**kwargs):
"""
Plot the ellipse from the fit results and draws the position of x_phi180
and x_phi0, which intersects the ellipse with the PV line
"""
for kwarg in mf.default_params:
kwargs[kwarg] = kwargs[kwarg] if kwarg in kwargs \
else mf.default_params[kwarg]
vla4b_sky = SkyCoord(*mf.default_params['vla4b_deg'], unit='deg')
# vla4b_pixel = skycoord_to_pixel(vla4b_sky, wcs)
xys_sky = generate_pv_line_coordinates(angle, box, wcs,
kwargs['n_points_PV'])
if ax is None:
plt.figure(figsize=(8, 8))
ax = plt.subplot(projection=wcs)
else:
pass
ax.plot(vla4b_sky.ra.deg,
vla4b_sky.dec.deg,
'*',
transform=ax.get_transform('world'))
# Plots the PV diagram
xs_sky = np.array([xy.ra.deg for xy in xys_sky])
ys_sky = np.array([xy.dec.deg for xy in xys_sky])
ax.plot(
xs_sky,
ys_sky,
transform=ax.get_transform('world'),
)
# Plots the special points
for p in [
dic_bb[bb]['data']['p180_sky'][chan],
dic_bb[bb]['data']['p0_sky'][chan]
]:
ax.plot(p.ra.value,
p.dec.value,
'+g',
zorder=3,
transform=ax.get_transform('world'))
# Plots the point of the ellipse
for point in dic_bb[bb]['ellipse_sky'][chan]:
ax.plot(point.ra.value,
point.dec.value,
'.w',
transform=ax.get_transform('world'))
# Plots a line of the elliptical fit
positions_deg = SkyCoord(ra=dic_bb[bb]['data']['x0_RA'][chan] * u.deg,
dec=dic_bb[bb]['data']['y0_DEC'][chan] * u.deg)
a_deg = dic_bb[bb]['data']['sma_deg'][chan] * u.deg
b_deg = dic_bb[bb]['data']['sma_deg'][chan] \
* (1. - dic_bb[bb]['data']['eps'][chan]) * u.deg
pa_deg = (dic_bb[bb]['data']['pa'][chan] -
np.pi / 2.) * 180 / np.pi * u.deg
aper = SkyEllipticalAperture(positions_deg, a_deg, b_deg, pa_deg)
aper2plot = aper.to_pixel(wcs)
aper2plot.plot(ax, color='b', alpha=0.5)
ax.set_aspect("equal")
mask2 = np.isnan(data_mom0)
mask = np.ma.mask_or(mask1, mask2)
data_masked = np.ma.masked_where(mask, y)
a = 1.5
incl = 0.45
b = 1.5 * incl
PA = 110
ra = 204.97066052
dec = 50.406569999999995
position = SkyCoord(dec=dec * u.arcmin, ra=ra * u.degree, frame='icrs')
core_sky = SkyEllipticalAperture(position,
a=a * u.arcsec,
b=b * u.arcsec,
theta=PA * u.degree)
core_pix = core_sky.to_pixel(wcs=wcs)
core_mask = Apmask_convert(core_pix, data_masked)
core_masked = np.ma.masked_where(core_mask, y)
disk_masked = np.ma.masked_where(~core_mask, y)
# ## plot the scattering plot
# x=sd
# fig=plt.figure()
# ax=plt.axes(xscale='log',yscale='log')
# plt.plot(x.flatten(),y.flatten(),'.',color='red',label='disk')
# plt.plot(x.flatten(),core_masked.flatten(),'.',color='blue',label='core')
# # plt.ylim(top=300,bottom=8)
# # plt.xlim(left=40)
# plt.ylabel('velocity dispersion (km/s)')
# plt.xlabel('surface density (solar mass/pc**2)')
# plt.title('conversion factor 4.3')
def plot_friends(friendid, friend_cat, cutout, k=3.5, ax=None, label=True):
"""
Plot a friends group from the fof_kdtree clustering output.
Adapted from Niv Drory's original code
Parameters
----------
friends: int
unique group identifier
friend_cat:
the combined group+detections catalog
ax
optional axis object to project coords onto
"""
im = cutout["cutout"].data
wcs = cutout["cutout"].wcs
if ax is None:
ax = fig.add_subplot(111, project=wcs)
im_zscale = ZScaleInterval(contrast=0.5, krej=2.5)
im_vmin, im_vmax = im_zscale.get_limits(values=cutout["cutout"].data)
plt.imshow(
cutout["cutout"].data,
vmin=im_vmin,
vmax=im_vmax,
origin="lower",
cmap=plt.get_cmap("gray"),
interpolation="none",
)
sel = friend_cat["friendid"] == friendid
group = friend_cat[sel]
coords = SkyCoord(ra=group["icx"][0] * u.deg, dec=group["icy"][0] * u.deg)
# get ellipse parameters in degrees
a, b, pa, a2, b2, pa2 = (
group["a"][0],
group["b"][0],
group["pa"][0],
group["a2"][0],
group["b2"][0],
group["pa2"][0],
)
# plot detections for group
plt.scatter(
group["ra"],
group["dec"],
transform=ax.get_transform("fk5"),
marker="x",
color="orange",
linewidth=1,
s=group["flux"],
)
# plot and elliptical kron-like aperture representing the group
# theta is measured
aper_group = SkyEllipticalAperture(
coords, a * u.deg, b * u.deg, theta=(90 - pa) * u.deg
)
aper_group_k = SkyEllipticalAperture(
coords, k * a * u.deg, k * b * u.deg, theta=(90 - pa) * u.deg
)
aper_group.to_pixel(wcs).plot(color="blue")
aper_group_k.to_pixel(wcs).plot(color="red")
if label:
# plot detecid labels
for row in group:
plt.text(
row["ra"],
row["dec"],
str(row["detectid"]),
transform=ax.get_transform("world"),
fontsize=9,
color="red",
)
center_sky = SkyCircularAperture(position, r=3 * u.arcsec)
center_pix = center_sky.to_pixel(wcs=wcs)
apertures['center'] = center_pix
ring_sky = SkyCircularAnnulus(position, r_in=3 * u.arcsec, r_out=7 * u.arcsec)
ring_pix = ring_sky.to_pixel(wcs=wcs)
apertures['ring'] = ring_pix
position = SkyCoord(dec=0.8340 * u.degree,
ra=204.9935 * u.degree,
frame='icrs')
northarm_sky = SkyEllipticalAperture(position,
a=13 * u.arcsec,
b=4 * u.arcsec,
theta=185 * u.degree)
northarm_pix = northarm_sky.to_pixel(wcs=wcs)
apertures['northarm'] = northarm_pix
position = SkyCoord(dec=0.8283 * u.degree,
ra=204.9882 * u.degree,
frame='icrs')
southarm_sky = SkyEllipticalAperture(position,
a=9 * u.arcsec,
b=4 * u.arcsec,
theta=360 * u.degree)
southarm_pix = southarm_sky.to_pixel(wcs=wcs)
apertures['southarm'] = southarm_pix
# measure the flux
rms_12CO10 = 0.00158
chan_width = 10
############################################################
# main program
Image=imageDir+'NGC5258_12CO10_combine_contsub_mom0.fits'
wcs_cut=fits_import(Image)[0]
data_cut=fits_import(Image)[1]
shape=data_cut.shape
flux=np.empty(shape=(0,0))
counts=np.empty(shape=(0,0))
uncertainties=np.empty(shape=(0,0))
# draw the center of the image
a=radius_arcsec[0]
b=radius_arcsec[0]*incl
center_sky=SkyEllipticalAperture(position,a=a*u.arcsec,b=b*u.arcsec,theta=PA*u.degree)
center_pix=center_sky.to_pixel(wcs=wcs_cut)
center_mask=Apmask_convert(center_pix,data_cut)
# draw the ring of the image
for i in range(int(steps-1)):
rings[i]=aperture_ring(radius_arcsec[i+1],wcs_cut)
rings_mask[i]=Apmask_convert(rings[i],data_cut)
fig=plt.figure()
ax=plt.subplot(projection=wcs_cut)
ax.imshow(data_cut,origin='lower')
# center_pix.plot(color='red')
# for i in range(size):
# rings[i].plot(color='red')
# plt.show()
rings[3].plot(color='red')
### moment 0 plot
fitsimage = mom0file
wcs = fits_import(fitsimage)[0]
mom0 = fits_import(fitsimage)[1]
size = u.Quantity((54, 42), u.arcsec)
wcs_cut = cut_2d(mom0, position, size, wcs)[0]
mom0_cut = cut_2d(mom0, position, size, wcs)[1]
# plot the beam size
beamellipse = SkyEllipticalAperture(positions=beamposition,
a=beammajor,
b=beamminor,
theta=pa)
beamellipse_pix = beamellipse.to_pixel(wcs_cut)
try:
gama
except:
gama = 1.0
fig = plt.figure()
ax = plt.subplot('111', projection=wcs_cut)
x, y = wcs_cut.wcs_world2pix(testra, testdec, 1)
props = dict(facecolor='white', alpha=0.5, edgecolor='None')
plt.text(x, y, galaxy + ' ' + linelabel, fontsize=15, bbox=props)
ax.tick_params(labelsize=8, direction='in')
imageDir = Dir + 'casa5.4/'
regionDir = Dir + 'region/'
fitsimage = imageDir + 'NGC5257_12CO10_combine_contsub_pbcor_mom0.fits'
wcs = fits_import(fitsimage)[0]
data_masked = fits_import(fitsimage)[1]
data = data_masked.data
major = 0.5 / 0.48 * u.arcsec
minor = major * incl
centersky = SkyEllipticalAperture(positions=position,
a=major,
b=minor,
theta=PA)
centerpix = centersky.to_pixel(wcs)
masked = Apmask_convert(centerpix, data)
intensity_center = np.ma.mean(masked) * incl
regionfile = regionDir + 'detection.reg'
whole = read_ds9(regionfile)[0]
whole_pix = whole.to_pixel(wcs)
def Apmask_convert(aperture, data_cut):
apmask = aperture.to_mask()
shape = data_cut.shape
mask = apmask.to_image(shape=((shape[0], shape[1])))
ap_mask = mask == 0
ap_masked = np.ma.masked_where(ap_mask, data_cut)
def sub_image(fig, hdu, FRB, img_center=None,
imsize=30*units.arcsec, vmnx = (None,None),
xyaxis=(0.15, 0.15, 0.8, 0.8), fsz=15.,
tick_spacing=None, invert=False,
cmap='Blues', frb_clr='red'):
"""
Args:
fig:
hdu:
FRB:
img_center:
imsize:
vmnx:
xyaxis:
fsz:
tick_spacing:
invert:
cmap:
cclr:
Returns:
"""
if isinstance(hdu, fits.HDUList):
hdu = hdu[0]
header = hdu.header
hst_uvis = hdu.data
size = units.Quantity((imsize, imsize), units.arcsec)
if img_center is None:
img_center = FRB.coord
cutout = Cutout2D(hst_uvis, img_center, size, wcs=WCS(header))
axIMG = fig.add_axes(xyaxis, projection=cutout.wcs)
lon = axIMG.coords[0]
lat = axIMG.coords[1]
#lon.set_ticks(exclude_overlapping=True)
lon.set_major_formatter('hh:mm:ss.s')
if tick_spacing is not None:
lon.set_ticks(spacing=tick_spacing)
lat.set_ticks(spacing=tick_spacing)
lon.display_minor_ticks(True)
lat.display_minor_ticks(True)
#
blues = plt.get_cmap(cmap)
d = axIMG.imshow(cutout.data, cmap=blues, vmin=vmnx[0], vmax=vmnx[1])
plt.grid(color='gray', ls='dashed')
axIMG.set_xlabel(r'\textbf{Right Ascension (J2000)}', fontsize=fsz)
axIMG.set_ylabel(r'\textbf{Declination (J2000)}', fontsize=fsz, labelpad=-1.)
if invert:
axIMG.invert_xaxis()
#c = SphericalCircle((FRB.coord.ra, FRB.coord.dec),
# FRB.eellipse['a']*units.arcsec, transform=axIMG.get_transform('icrs'),
# edgecolor=cclr, facecolor='none')
aper = SkyEllipticalAperture(positions=FRB.coord,
a=FRB.sig_a * units.arcsecond,
b=FRB.sig_b * units.arcsecond,
theta=FRB.eellipse['theta'] * units.deg)
apermap = aper.to_pixel(cutout.wcs)
apermap.plot(color=frb_clr, lw=2, ls='dashed')
'''
ylbl = 0.05
axHST.text(0.05, ylbl, r'\textbf{HST/UVIS}', transform=axIMG.transAxes,
fontsize=isz, ha='left', color='black')
'''
utils.set_fontsize(axIMG, 15.)
return cutout, axIMG
# #### compare with moment 2 map.
seperation = data3['RAD(arcs)'][1] - data3['RAD(arcs)'][0]
rings = dict.fromkeys(range(data3.shape[0]))
rings_mask = dict.fromkeys(range(data3.shape[0]))
size = data3.shape[0]
mom2 = Imcube.linewidth_sigma()
wcs = WCS(mom2.hdu.header)
radius_arc = data3['RAD(arcs)'] + seperation / 2
center_sky = SkyEllipticalAperture(positions=center,
a=radius_arc[0] * u.arcsec,
b=radius_arc[0] * cosi * u.arcsec,
theta=pa * u.degree)
rings[0] = center_sky.to_pixel(wcs=wcs)
rings_mask[0] = Apmask_convert(rings[0], np.array(mom2))
def aperture_rings(a_in, a_out, wcs, cosi, pa):
ring_sky = SkyEllipticalAnnulus(positions=center,
a_in=a_in * u.arcsec,
a_out=a_out * u.arcsec,
b_out=a_out * cosi * u.arcsec,
theta=pa * u.degree)
ring_pix = ring_sky.to_pixel(wcs=wcs)
return ring_pix
for i in range(1, size):
rings[i] = aperture_rings(radius_arc[i - 1], radius_arc[i], wcs, cosi, pa)
imageDir = Dir + 'image/'
picDir = Dir + 'picture/'
## comparision for 12CO10 data
fitsimage = imageDir + 'NGC5257_12CO10_combine_contsub_mom2.fits'
wcs = fits_import(fitsimage)[0]
data_masked = fits_import(fitsimage)[1]
data = data_masked.data
a = radius_arcsec[0]
b = radius_arcsec[0] * incl
center_sky = SkyEllipticalAperture(position,
a=a * u.arcsec,
b=b * u.arcsec,
theta=PA * u.degree)
center_pix = center_sky.to_pixel(wcs=wcs)
center_mask = Apmask_convert(center_pix, data_masked)
for i in range(8):
rings[i] = aperture_ring(radius_arcsec[i + 1], wcs)
rings_mask[i] = Apmask_convert(rings[i], data_masked)
dispersions = np.empty((0, 0))
dispersions = np.append(dispersions, np.ma.median(center_mask))
for i in range(8):
dispersion = np.ma.median(rings_mask[i])
dispersions = np.append(dispersions, dispersion)
# fig=plt.figure()
# ax=plt.subplot(projection=wcs)
# im=ax.imshow(data,cmap='rainbow',origin='lower',vmax=150)
south_syn = 6.64 * 10**(-29) * 33**0.7 * L_33
south_fre = 4.6 * 10**(-28) * 33**(0.1) * L_33
fitsimage = 'NGC5257_33GHz_smooth.fits'
wcs_33smo = fits_import('NGC5257_33GHz_smooth.fits')[0]
data_33smo = fits_import('NGC5257_33GHz_smooth.fits')[1]
# test the position of fitted beam for 33GHz data for smoothed beam
position = SkyCoord(dec=0.0146051786921 * u.rad,
ra=-2.7057736283 * u.rad,
frame='fk5')
south_sky = SkyEllipticalAperture(position,
a=3 * ratio * u.arcsec,
b=3 * ratio * u.arcsec,
theta=0.0 * u.degree)
south_pix = south_sky.to_pixel(wcs=wcs_33smo)
# fig=plt.figure()
# ax=plt.subplot(projection=wcs_33smo)
# ax.imshow(data_33smo,origin='lower')
# south_pix.plot()
# # plt.savefig(picDir+'33GHz_south.png')
south_33 = south_pix
beamarea = 1.1331 * 5.76 * 5.46
beamarea_pix = beamarea / (0.12**2)
data_cut = data_33smo
aperture = south_33
flux = flux_aperture_get(data_33smo, aperture)
flux_33 = flux / beamarea_pix
df['flux']['33GHz'] = flux_33
