def get_one_contrast_and_SN(data, positions, fwhm, fwhm_flux):
'''
Args:
path : a string. The path of repository where the files are.
positions : a list of tuple (x,y). The coordinates of companions.
Return:
flux : a np.array, 1 dimension. Store the list of each companion's flux.
SN : a np.array, 1 dimension. Store the list of each companion's Signal to Noise ratio.
'''
# flux
aperture = CircularAperture(positions, r=2)
annulus = CircularAnnulus(positions, r_in=4, r_out=6)
# flux
flux_companion = aperture_photometry(data, [aperture, annulus])
flux_companion['aperture_sum_0', 'aperture_sum_1'].info.format = '%.8g'
flux = (flux_companion['aperture_sum_0'] / aperture.area) / fwhm_flux
# SN
ds9 = vip.Ds9Window()
ds9.display(data)
SN = vip.metrics.snr(data, source_xy=positions[0], fwhm=fwhm, plot=True)
return flux[0], SN
def get_contrast_and_SN(res_fake, res_real, positions, fwhm_for_snr, fwhm_flux,
r_aperture, r_in_annulus, r_out_annulus):
'''
Args:
res_fake : a 2D np.array. The path of repository where the files are.
res_real : a 2D np.array. The path of another repository where the files are, for calculating snr.
positions : a list of tuple (x,y). The coordinates of companions.
fwhm : a float. fwhm's diameter.
fwhm_flux : a float. The flux of fwhm.
Return:
contrast : a np.array, 1 dimension. Store the list of each companion's flux.
SN : a np.array, 1 dimension. Store the list of each companion's Signal to Noise ratio.
'''
aperture = CircularAperture(positions, r=r_aperture)
annulus = CircularAnnulus(positions,
r_in=r_in_annulus,
r_out=r_out_annulus)
# contrast
flux_companion = aperture_photometry(res_fake, [aperture, annulus])
flux_companion['aperture_sum_0', 'aperture_sum_1'].info.format = '%.8g'
flux = flux_companion['aperture_sum_0']
contrast = (flux_companion['aperture_sum_0']) / fwhm_flux
# SN
SN = vip.metrics.snr(array=res_fake,
source_xy=positions,
fwhm=fwhm_for_snr,
plot=False,
array2=res_real,
use2alone=True)
return contrast.data[0], SN, flux.data[0]
def set_aperture_properties(self):
"""
Calculate the aperture photometry.
The values are set as dynamic attributes.
"""
apertures = [
CircularAperture(self._xypos_finite, radius)
for radius in self.aperture_params['aperture_radii']
]
aper_phot = aperture_photometry(self.model.data,
apertures,
error=self.model.err)
for i, aperture in enumerate(apertures):
flux_col = f'aperture_sum_{i}'
flux_err_col = f'aperture_sum_err_{i}'
# subtract the local background measured in the annulus
aper_phot[flux_col] -= (self.aper_bkg_flux * aperture.area)
flux = aper_phot[flux_col]
flux_err = aper_phot[flux_err_col]
abmag, abmag_err = self.convert_flux_to_abmag(flux, flux_err)
vegamag = abmag - self.abvega_offset
vegamag_err = abmag_err
idx0 = 2 * i
idx1 = (2 * i) + 1
setattr(self, self.aperture_flux_colnames[idx0], flux)
setattr(self, self.aperture_flux_colnames[idx1], flux_err)
setattr(self, self.aperture_abmag_colnames[idx0], abmag)
setattr(self, self.aperture_abmag_colnames[idx1], abmag_err)
setattr(self, self.aperture_vegamag_colnames[idx0], vegamag)
setattr(self, self.aperture_vegamag_colnames[idx1], vegamag_err)
def get_sky_from_annulus(self, r_in=3, r_out=5, units='arcsec'):
""" Measure the sky flux with aperture photometry in an annulus.
:param r_in, r_out: float
inner, outer radius of the sky annulus
:param units: 'arcsec' or 'pixels'
units for the radii.
:return: skyval : the measured average sky brightness per pixel.
"""
self.skyxy = [self.x_0, self.y_0]
if units.lower()=='arcsec':
r_in = r_in / self.pixscale
r_out = r_out / self.pixscale
elif not units.lower().startswith('pix'):
raise RuntimeError('Unknown unit %s'%units)
skyannulus = CircularAnnulus(self.skyxy, r_in=r_in, r_out=r_out)
phot_table = aperture_photometry(
self.imdat, skyannulus, error=None, mask=None,
method=u'exact', subpixels=5, unit=None, wcs=None)
skyvaltot = phot_table['aperture_sum']
self.skyannpix = [r_in, r_out]
self.skyvalperpix = skyvaltot / skyannulus.area()
# TODO: compute the error properly
self.skyerr = 0.0
return
def redoAperturePhotometry(catalog, imagedata, aperture, annulus_inner,
annulus_outer):
""" Recalculate the FLUX column off a fits / BANZAI CAT extension based on operature photometry. """
_logger.info("redoing aperture photometry")
positions = [(catalog['x'][ii], catalog['y'][ii])
for ii in range(len(catalog['x']))]
apertures = CircularAperture(positions, r=aperture)
sky_apertures = CircularAnnulus(positions,
r_in=annulus_inner,
r_out=annulus_outer)
sky_apertures_masks = sky_apertures.to_mask(method='center')
bkg_median = []
for mask in sky_apertures_masks:
annulus_data = mask.multiply(imagedata)
annulus_data_1d = annulus_data[mask.data > 0]
_, median_sigclip, _ = sigma_clipped_stats(annulus_data_1d)
bkg_median.append(median_sigclip)
bkg_median = np.array(bkg_median)
phottable = aperture_photometry(imagedata, [apertures, sky_apertures])
# plt.plot (phottable['aperture_sum_1'] / sky_apertures.area, phottable['aperture_sum_1'] / sky_apertures.area - bkg_median,'.')
# plt.savefig ('sky.png')
newflux = phottable['aperture_sum_0'] - bkg_median * apertures.area
# oldmag = -2.5 * np.log10(catalog['FLUX'])
# newmag = -2.5 * np.log10 (newflux)
# _logger.info ( newmag - oldmag)
# plt.plot (newmag, newmag - oldmag, '.')
# plt.savefig("Comparison.png")
catalog['FLUX'] = newflux
def create_dao_like_sourcelists(fitsfile,
sl_filename,
sources,
aper_radius=4.,
make_region_file=False):
"""Make DAOphot-like sourcelists
Parameters
----------
fitsfile : string
Name of the drizzle-combined filter product to used to generate photometric sourcelists.
sl_filename : string
Name of the sourcelist file that will be generated by this subroutine
sources : astropy table
Table containing x, y coordinates of identified sources
aper_radius : float
Aperture radius (in pixels) used for photometry. Default value = 4.
make_region_file : Boolean
Generate ds9-compatible region file(s) along with the sourcelist? Default value = False
Returns
-------
Nothing.
"""
# Open and background subtract image
hdulist = fits.open(fitsfile)
image = hdulist['SCI'].data
image -= np.nanmedian(image)
# Aperture Photometry
positions = (sources['xcentroid'], sources['ycentroid'])
apertures = CircularAperture(positions, r=aper_radius)
phot_table = aperture_photometry(image, apertures)
for col in phot_table.colnames:
phot_table[col].info.format = '%.8g' # for consistent table output
hdulist.close()
# Write out sourcelist
tbl_length = len(phot_table)
phot_table.write(sl_filename, format="ascii.ecsv")
log.info("Created sourcelist file '{}' with {} sources".format(
sl_filename, tbl_length))
# Write out ds9-compatable .reg file
if make_region_file:
reg_filename = sl_filename.replace(".ecsv", ".reg")
out_table = phot_table.copy()
out_table['xcenter'].data = out_table['xcenter'].data + np.float64(1.0)
out_table['ycenter'].data = out_table['ycenter'].data + np.float64(1.0)
out_table.remove_column('id')
out_table.write(reg_filename, format="ascii")
log.info("Created region file '{}' with {} sources".format(
reg_filename, tbl_length))
def calculateFluxes(data,wcs): pixelCenter = wcs.world_to_pixel_values(center[0],center[1]) pixelCenter = (float(pixelCenter[0]),float(pixelCenter[1])) apertures = getCircularApetures(pixelCenter,pixelRadius) error = np.sqrt(data) # have to remove the nans nanLocs = np.isnan(error) error[nanLocs]=0 fluxes = [] fluxErrors = [] for aperture in apertures: print(aperture_photometry(data,aperture,error=error)) fluxErrors.append(list(aperture_photometry(data,aperture,error=error)['aperture_sum_err'])[0]) fluxes.append(list(aperture_photometry(data,aperture,error=error)['aperture_sum'])[0]) return np.array(fluxes), np.array(fluxErrors),pixelCenter
def compute_eff_radii(image, plot=False):
max_pix_rad = np.min(image.shape) // 2
radius = np.arange(3, max_pix_rad, 3)
fake_image = np.zeros_like(image)
fake_image[max_pix_rad // 2:(3 * max_pix_rad) // 2,
max_pix_rad // 2:(3 * max_pix_rad) //
2] = image[max_pix_rad // 2:(3 * max_pix_rad) // 2,
max_pix_rad // 2:(3 * max_pix_rad) // 2]
com_x, com_y = centroid_2dg(fake_image)
aperture_sum = []
for rad_i in radius:
aperture = CircularAperture((com_x, com_y), r=rad_i)
phot_table = aperture_photometry(image, aperture)
aperture_sum.append(phot_table['aperture_sum'].value)
aperture_sum = np.array(aperture_sum).squeeze()
norm_aperture_sum = aperture_sum / aperture_sum[-1]
half_mass_rad = np.interp(0.5, norm_aperture_sum, radius)
half_mass_aperture = CircularAperture((com_x, com_y), r=half_mass_rad)
two_half_mass_aperture = CircularAperture((com_x, com_y),
r=2 * half_mass_rad)
half_mass_table = aperture_photometry(image, half_mass_aperture)
two_half_mass_table = aperture_photometry(image, two_half_mass_aperture)
if plot:
fig = plt.figure()
plt.imshow(np.log10(image))
plt.colorbar(label='log(image)')
plt.plot(com_x, com_y, '+', markersize=8, color='c')
half_mass_aperture.plot(color='r', lw=2, label=r'Half mass rad')
two_half_mass_aperture.plot(color='orange',
lw=2,
label=r'Two half mass rad')
plt.annotate(
'Tot mass={:.2}\nHalf mass={:.2}\nTwoHalf mass={:.2}'.format(
float(aperture_sum[-1]),
float(half_mass_table['aperture_sum'].value),
float(two_half_mass_table['aperture_sum'].value)),
xy=(.1, 1),
xycoords='axes fraction',
va='bottom')
plt.legend()
plt.close()
return half_mass_aperture, two_half_mass_aperture, fig
else:
return half_mass_aperture, two_half_mass_aperture
def get_contrast_and_SN(path, positions, fwhm, fwhm_flux, path_real):
'''
Args:
path : a string. The path of repository where the files are.
positions : a list of tuple (x,y). The coordinates of companions.
fwhm : a float. fwhm's diameter.
fwhm_flux : a float. The flux of fwhm.
path_real : a string. The path of another repository where the files are, for calculating snr.
Return:
contrast : a np.array, 1 dimension. Store the list of each companion's flux.
SN : a np.array, 1 dimension. Store the list of each companion's Signal to Noise ratio.
'''
files = os.listdir(path)
files.sort()
files_real = os.listdir(path_real)
files_real.sort()
l = len(files)
flux = np.zeros(l)
# contrast
contrast = np.zeros(l)
aperture = CircularAperture(positions, r=2)
annulus = CircularAnnulus(positions, r_in=4, r_out=6)
# SN
SN = np.zeros(l)
for i in range(l):
file = path+'/'+files[i]
print("file",i,"=", file)
data = vip.fits.open_fits(file)
# contrast
flux_companion = aperture_photometry(data, [aperture, annulus])
flux_companion['aperture_sum_0','aperture_sum_1'].info.format = '%.8g'
#bkg_mean = flux_companion['aperture_sum_1']/annulus.area
#bkg_sum_in_companion = bkg_mean * aperture.area
flux[i] = flux_companion['aperture_sum_0']
contrast[i] = (flux_companion['aperture_sum_0']/aperture.area)/fwhm_flux
# SN
lets_plot = False
if i==2:
lets_plot = True
#ds9.display(data)
file_real = path_real+'/'+files_real[i]
print("array2 at ",i," =", file_real)
data2 = vip.fits.open_fits(file_real)
SN[i] = vip.metrics.snr(array=data, source_xy=positions, fwhm=fwhm, plot=lets_plot, array2 = data2, use2alone=True)
return contrast, SN
def aper_phot(image, mask, xc, yc, radii, rsky, debug):
positions = [(xc, yc)]
# Define apertures
apertures = [CircularAperture(positions, r=r) for r in radii]
if (debug == 1):
# print("line ", lineno()," apertures : ", apertures)
print("line ", lineno(), " aper_phot: positions: ", positions)
print("line ", lineno(), " aper_phot: sky aperture ", rsky)
# for rr in range(0,len(radii)):
# print("line ", lineno(), " apertures[rr].r, apertures[rr].area :", apertures[rr].r, apertures[rr].area )
# Background, masking bad pixels
annulus_aperture = CircularAnnulus(positions, r_in=rsky[0], r_out=rsky[1])
annulus_masks = annulus_aperture.to_mask(method='center')
bkg_median = []
for anm in annulus_masks:
annulus_data = anm.multiply(image)
annulus_data_1d = annulus_data[anm.data > 0]
if (debug == 1):
print("line ", lineno(), " aper_phot: annulus_data_1d.shape ",
annulus_data_1d.shape)
# Remove NaNs, Infs
annulus_data_1d = annulus_data_1d[np.isfinite(annulus_data_1d)]
_, median_sigclip, _ = sigma_clipped_stats(annulus_data_1d)
bkg_median.append(median_sigclip)
if (debug == 1):
print("line ", lineno(), " aper_phot: annulus_data_1d.shape ",
annulus_data_1d.shape)
print("line ", lineno(), " aper_phot: median sigclip",
median_sigclip)
if (debug == 1):
print("line ", lineno(), " aper_phot: bkg_median ", bkg_median)
phot_table = aperture_photometry(image, apertures, mask=mask)
#
junk = []
area_list = []
n = -1
for index in phot_table.colnames:
if ('aperture_sum' in index):
n = n + 1
array = phot_table[index].data[0]
flux = array.tolist()
bkg = apertures[n].area * bkg_median[0]
junk.append(flux - bkg)
area_list.append(apertures[n].area)
apflux = np.array(junk)
area = np.array(area_list)
# (diff, encircled) = differential(apflux,area,True,False)
return apflux, area
def calculateFluxes(self, center, pixelRadius):
pixelCenter = self.wcs.world_to_pixel_values(center[0], center[1])
pixelCenter = (float(pixelCenter[0]), float(pixelCenter[1]))
apertures = self.getCircularApetures(pixelCenter, pixelRadius)
error = np.sqrt(np.abs(self.data))
fluxes = []
fluxErrors = []
for aperture in apertures:
fluxErrors.append(
list(
aperture_photometry(self.data, aperture,
error=error)['aperture_sum_err'])[0])
fluxes.append(
list(
aperture_photometry(self.data, aperture,
error=error)['aperture_sum'])[0])
self.fluxes = np.array(fluxes)
self.fluxErrors = np.array(fluxErrors)
self.pixelCenter = pixelCenter
def get_contrast_and_SN_only_real(res_real, positions, fwhm_for_snr, psf,
r_aperture, r_in_annulus, r_out_annulus):
'''
Args:
res_real : a 2D np.array. The path of another repository where the files are, for calculating snr.
positions : a list of tuple (x,y). The coordinates of companions.
psf : a 2D np.array. The image of flux.
fwhm_flux : a float. The flux of fwhm.
r_aperture, r_in_annulus, r_out_annulus : see args.
Return:
contrast : a np.array, 1 dimension. Store the list of each companion's flux.
SN : a np.array, 1 dimension. Store the list of each companion's Signal to Noise ratio.
'''
aperture = CircularAperture(positions, r=r_aperture)
annulus = CircularAnnulus(positions,
r_in=r_in_annulus,
r_out=r_out_annulus)
# contrast
flux_companion = aperture_photometry(res_real, [aperture, annulus])
flux_companion['aperture_sum_0', 'aperture_sum_1'].info.format = '%.8g'
flux = flux_companion['aperture_sum_0']
x, y = psf.shape
aperture_psf = CircularAperture((x // 2, y // 2), r=r_aperture)
flux_psf = aperture_photometry(psf, aperture_psf)
flux_psf['aperture_sum'].info.format = '%.8g'
contrast = (flux_companion['aperture_sum_0']) / flux_psf['aperture_sum']
# SN
SN = vip.metrics.snr(array=res_real,
source_xy=positions,
fwhm=fwhm_for_snr,
plot=False)
return contrast.data[0], SN, flux.data[0]
def getApFlux(self, n, **kwargs: {'plot': False}):
aper = []
self.getFits()
#try:
for i in range(len(n)):
a = float(self.r['nsa_elpetro_th50_r']) * n[i]
b = a * float(self.r['nsa_elpetro_ba'])
phi = float(self.r['nsa_elpetro_phi']) * u.deg
#print(a,b,phi,self.ra,self.dec)
pos = SkyCoord(ra=self.ra, dec=self.dec, unit='deg')
aper.append(
ap.SkyEllipticalAperture(pos,
a * u.arcsec,
b * u.arcsec,
theta=phi))
#return aper
try:
f = fits.open(self.fP)
flux = ap.aperture_photometry(f[0], aper)
except:
er = 'Something went wrong in getAPFlux() for the file "' + self.fN + '" for scale radius=' + str(
n)
log.error(er)
print(er)
bad = [0.0, 0.0, 0.0, 0.0]
return bad
#return flux[0]['aperture_sum_0']
if kwargs.get('plot'):
self.viewImage()
fw = WCS(f[0].header)
aper[0].to_pixel(fw).plot(color='blue')
aper[1].to_pixel(fw).plot(color='red')
aper[2].to_pixel(fw).plot(color='green')
aper[3].to_pixel(fw).plot(color='yellow')
if self.band == 3:
arr = np.array([
flux[0]['aperture_sum_0'], flux[0]['aperture_sum_1'],
flux[0]['aperture_sum_2'], flux[0]['aperture_sum_3']
])
b3 = arr * 1.8326e-06
f.close()
return b3
if self.band == 4:
arr = np.array([
flux[0]['aperture_sum_0'], flux[0]['aperture_sum_1'],
flux[0]['aperture_sum_2'], flux[0]['aperture_sum_3']
])
b4 = arr * 5.2269E-05
f.close()
return b4
def get_SN(path, positions, fwhm):
'''
Args:
path : a string. The path of repository where the files are.
positions : a list of tuple (x,y). The coordinates of companions.
Return:
flux : a np.array, 1 dimension. Store the list of each companion's flux.
SN : a np.array, 1 dimension. Store the list of each companion's Signal to Noise ratio.
'''
files = os.listdir(path)
files.sort()
l = len(files)
# flux
flux = np.zeros(l)
aperture = CircularAperture(positions, r=2)
annulus = CircularAnnulus(positions, r_in=4, r_out=6)
# SN
SN = np.zeros(l)
for i in range(l):
file = path + '/' + files[i]
print("file", i, "=", file)
data = vip.fits.open_fits(file)
# flux
flux_companion = aperture_photometry(data, [aperture, annulus])
flux_companion['aperture_sum_0', 'aperture_sum_1'].info.format = '%.8g'
#bkg_mean = flux_companion['aperture_sum_1']/annulus.area
#bkg_sum_in_companion = bkg_mean * aperture.area
#flux[i] = flux_companion['aperture_sum_0'] - bkg_sum_in_companion
flux[i] = (flux_companion['aperture_sum_0'] / aperture.area)
# SN
lets_plot = False
if i == 2:
lets_plot = True
#ds9.display(data)
SN[i] = vip.metrics.snr(data,
source_xy=positions[0],
fwhm=fwhm,
plot=lets_plot)
return flux, SN
def aper_phot_old(image, xc, yc, radii, plot_results,profile_png, mask=None,verbose=False):
positions = [(xc, yc)]
apertures = [CircularAperture(positions, r=r) for r in radii ]
phot_table = aperture_photometry(image, apertures,mask=mask)
#
junk = []
# print(phot_table)
# print(type(phot_table))
for index in phot_table.colnames:
if('aperture_sum' in index):
array = phot_table[index].data[0]
temp = array.tolist()
junk.append(temp)
values = np.array(junk)
diff = np.zeros(len(values))
diff[0] = values[0]
for ii in range(1,len(values)):
diff[ii]= values[ii]-values[ii-1]
if(verbose == True or verbose == 1):
print(values[ii], diff[ii])
if(verbose == True or verbose == 1):
print("positions: " ,positions)
print("Radii :", radii)
print("values :",values)
if(plot_results == True) :
fig = plt.figure(figsize=(10,8))
plt.subplot(2, 1, 1)
plt.plot(radii, values,'bo',markersize=4)
plt.xlabel("radius (pixels)")
plt.ylabel("totalintensity")
plt.subplot(2, 1, 2)
diff = diff/diff[0]
plt.plot(radii, diff,'bo',markersize=4)
plt.yscale("log")
plt.xlabel("radius (pixels)")
plt.ylabel("Normalised intensity")
plt.savefig(profile_png,bbox_inches='tight')
plt.show()
return
def doapphot(self, apradlist, units='arcsec'):
""" Measure the flux in one or more apertures.
:param apradlist: float or array-like
aperture radius or list of radii.
:param units: 'arcsec' or 'pixels';
the units for the aperture radii in apradlist.
"""
if not np.iterable(apradlist):
apradlist = [apradlist]
if units == 'arcsec':
apradlist = [ap / self.pixscale for ap in apradlist]
if self.skyvalperpix is None:
self.get_sky_from_annulus()
xy = [self.x_0, self.y_0]
apertures = [CircularAperture(xy, r) for r in apradlist]
phot_table = aperture_photometry(
self.imdat, apertures, error=None, mask=None,
method=u'exact', subpixels=5, unit=None, wcs=None)
# Modify the output photometry table
if 'aperture_sum' in phot_table.colnames:
# if we had only a single aperture, then the aperture sum column
# has no index number at the end. So we add it.
phot_table.rename_column('aperture_sum', 'aperture_sum_0')
for i in range(len(apertures)):
# add a column for each aperture specifying the radius in arcsec
colname = 'radius_arcsec_{:d}'.format(i)
apradarcsec = apradlist[i] * self.pixscale
apcol = Column(name=colname, data=[apradarcsec,])
phot_table.add_column(apcol)
self._photutils_output_dict['aperturephot'] = \
MeasuredPhotometry('aperturephot', 'aperture')
self._photutils_output_dict['aperturephot'].photresultstable = \
phot_table
self._photutils_output_dict['aperturephot'].get_flux_and_mag(
self.zpt, self.camera, self.filter)
def get_photometry(path):
'''
Args:
path : a string. The path of repository where the files are.
Rrturn:
res : a np.array, 1 dimension. Store the list of each companion's flux.
SN : a np.array, 1 dimension. Store the list of each companion's Signal to Noise ratio.
'''
files = os.listdir(path)
files.sort()
res = np.zeros((len(files)))
SN = np.zeros(len(files))
for i in range(len(res)):
file = path+'/'+files[i]
print("file =",file)
data = fits.getdata(file)
flux_companion = aperture_photometry(data, [aperture, annulus])
flux_companion['aperture_sum_0','aperture_sum_1'].info.format = '%.8g'
bkg_mean = flux_companion['aperture_sum_1']/annulus.area
bkg_sum_in_companion = bkg_mean * aperture.area
annulus_stdev = get_stdev(data)
res[i] = flux_companion['aperture_sum_0'] - bkg_sum_in_companion
SN[i] = res[i] / (annulus_stdev * aperture.area)
if i==1 and SHOW_POSITION:
norm = simple_norm(data, 'sqrt', percent=99)
plt.imshow(data, norm=norm, interpolation='nearest')
ap_patches = aperture.plot(color='white', lw=2, label='Photometry aperture')
ann_patches = annulus.plot(color='red', lw=2, label='Background annulus')
handles = (ap_patches[0],ann_patches[0])
plt.legend(loc=(0.17, 0.05), facecolor='#458989', labelcolor='white', handles=handles, prop={'weight':'bold', 'size':11})
plt.xlim(100,170)
plt.ylim(200,256)
#plt.savefig('./circle_ADI/ADI_32px_'+str(i))
plt.show()
return res, SN
def photutils_apphot(datestr):
"""
Run aperture photometry using photutils.
Extract LCs for Tmag < 16 stars within 6 arcminutes of TOI 837.
And also do the "custom apertures" along a line between TOI 837 and Star A.
"""
imgpaths, outdir = ____init_dir(datestr)
# J2015.5 gaia TOI 837
ra, dec = 157.03728055645, -64.50521068147
c_obj = SkyCoord(ra, dec, unit=(u.deg), frame='icrs')
# J2015.5 gaia, Star A = TIC 847769574 (T=14.6). $2.3$'' west
# == Gaia 5251470948222139904
A_ra, A_dec = 157.03581886712300, -64.50508245570860
c_StarA = SkyCoord(A_ra, A_dec, unit=(u.deg), frame='icrs')
# will do photometry along the line separating these two stars.
posn_angle = c_obj.position_angle(c_StarA)
sep = c_obj.separation(c_StarA)
# number of pixels to shift. sign was checked empirically.
npxshift = -np.arange(0, 6.5, 0.5)
px_scale = 0.734 * u.arcsec # per pixel
line_ap_locs = []
for n in npxshift:
line_ap_locs.append(
c_StarA.directional_offset_by(posn_angle, n * px_scale))
# sanity check: 3 pixel shift should be roughly location of TOI 837
assert np.round(ra, 3) == np.round(line_ap_locs[6].ra.value, 3)
nbhr_stars, sra, sdec, ticids = get_nbhr_stars()
positions = SkyCoord(sra, sdec, unit=(u.deg), frame='icrs')
#
# apertures of radii 1-7 pixels, for all stars in image
#
n_pxs = range(1, 8)
aplist = []
for n in n_pxs:
aplist.append(pa.SkyCircularAperture(positions, r=n * px_scale))
#
# finally, do the photometry.
#
for imgpath in imgpaths:
outpath = os.path.join(
outdir,
os.path.basename(imgpath).replace('.fit', '_phottable.fits'))
if os.path.exists(outpath):
print('found {}, skip.'.format(outpath))
continue
hdul = fits.open(imgpath)
img = hdul[0].data
img_wcs = wcs.WCS(hdul[0].header)
hdul.close()
phot_table = pa.aperture_photometry(img, aplist, wcs=img_wcs)
#
# apertures of radii 1-7 pixels, along the line between Star A and TOI
# 837.
#
custom_aplist = []
custom_phottables = []
line_ap_locs = SkyCoord(line_ap_locs)
for n in range(1, 8):
custom_aplist.append(
pa.SkyCircularAperture(line_ap_locs, r=n * px_scale))
custom_phot_table = pa.aperture_photometry(img,
custom_aplist,
wcs=img_wcs)
#
# save both
#
outpath = os.path.join(
outdir,
os.path.basename(imgpath).replace('.fit', '_phottable.fits'))
phot_table.write(outpath, format='fits')
print('made {}'.format(outpath))
outpath = os.path.join(
outdir,
os.path.basename(imgpath).replace('.fit', '_customtable.fits'))
custom_phot_table.write(outpath, format='fits')
print('made {}'.format(outpath))
plt.imshow(img2, cmap='gray', origin='lower')
apertures[22].plot(color='white')
apertures[20].plot(color='white')
K = 24
name = "Br_Imbrium_pt2_"
lcurves = [np.zeros((2, 2)) for i in range(4)]
for I in range(len(lists)):
for J in range(len(lists[I])):
fil = lists[I][J]
img = fit.open(fil)[0].data
hdr = fit.open(fil)[0].header
dt = hdr['DATE-OBS']
tsep = datetime.datetime.strptime(dt, '%Y-%m-%dT%H:%M:%S')
time = np.int(tsep.strftime('%s'))
phot = apphot.aperture_photometry(img, apertures[K])
sums = float(phot['aperture_sum']) / hdr['EXPTIME']
lcurves[I] = np.vstack((lcurves[I], np.array([time, sums])))
lcurves[I] = np.delete(lcurves[I], 0, axis=0)
lcurves[I] = np.delete(lcurves[I], 0, axis=0)
plt.plot(lcurves[I][:, 0], lcurves[I][:, 1])
plt.yscale('log')
plt.savefig(save_in + "plots/" + name + types[I])
plt.close()
np.savetxt(save_in + name + types[I], lcurves[I])
plt.savefig(save_in + "B_Imbrium_bl")
#plt.plot(lcurves[0][:,0],lcurves[0][:,1]);plt.yscale('log')
np.savetxt(save_in + "B_Imbrium_bl", lcurves[0])
np.savetxt(save_in + "B_Imbrium_IR", lcurves[1])
coeff = chebfit(x_sky[~clip_mask], sky_val[~clip_mask], deg=ORDER_APSKY)
data_skysub.append(cut_i - chebval(np.arange(cut_i.shape[0]), coeff))
data_skysub = np.array(data_skysub).T
hdr = objhdu[0].header
hdr.add_history(f"Sky subtracted using sky offset = {ap_sky_offset}, " +
f"{SIGMA_APSKY}-sigma {ITERS_APSKY}-iter clipping " +
f"to fit order {ORDER_APSKY} Chebyshev")
_ = fits.PrimaryHDU(data=data_skysub, header=hdr)
_.data = _.data.astype('float32')
_.writeto(DATAPATH / (OBJIMAGE.stem + ".skysub.fits"), overwrite=True)
pos = np.array([x_ap, y_ap]).T
aps = RectangularAperture(positions=pos, w=1, h=apheight, theta=0)
phot = aperture_photometry(data_skysub, aps, method='subpixel', subpixels=30)
ap_summed = phot['aperture_sum'] / EXPTIME
fig, axs = plt.subplots(2,
1,
figsize=(10, 6),
sharex=False,
sharey=False,
gridspec_kw=None)
axs[0].imshow(objimage, vmin=3000, vmax=6000, origin='lower')
axs[1].imshow(data_skysub, vmin=0, vmax=200, origin='lower')
axs[0].set(title="Before sky subtraction")
axs[1].set(title="Sky subtracted")
for ax in [axs[0], axs[1]]:
ax.plot(x_ap, y_ap + apsum_sigma_upper * ap_sigma, 'r-', lw=1)
if nb_wl > 1:
fwhm_bis = get_fwhm_from_psf(psf[1])
psfn_bis = vip.metrics.normalize_psf(psf[1], fwhm_bis, size=17)
print("psfn =", psfn_bis.shape, "psfn.ndim =", psfn_bis.ndim)
# pxscale of IRDIS
pxscale = get_pxscale()
# get flux level
psf_nx, psf_ny = psf[wl_final].shape
position = (psf_nx // 2, psf_ny // 2)
aperture = CircularAperture(position, r=(diameter / 2))
annulus = CircularAnnulus(position, r_in=diameter, r_out=diameter * (3 / 2))
flux_psf = aperture_photometry(psf[wl_final], [aperture, annulus])
flux_psf['aperture_sum_0', 'aperture_sum_1'].info.format = '%.8g'
flux_level = flux_psf['aperture_sum_0'][0] * contrast
print(">> flux of psf in the same aperture is:", flux_psf['aperture_sum_0'][0],
"contrast is:", contrast)
print(">> flux_level =", flux_level)
################################
# Step-3 do the fake injection #
################################
# use vip to inject a fake companion
science_cube_fake_comp = np.zeros((2, nb_science_frames, nx, ny))
science_cube_fake_comp[wl_final] = vip.metrics.cube_inject_companions(
science_cube[wl_final],
plt.figure(1)
plt.clf()
# label the sources
mylabels = sources['id']
for idx, txt in enumerate(mylabels):
plt.annotate(txt, (positions[idx, 0], positions[idx, 1]))
plt.imshow(np.log(imdata), cmap='Greys')
apertures.plot(color='red', lw=1.5, alpha=0.5)
annulus.plot(color='green', lw=1.5, alpha=0.5)
plt.show()
# sum signal in source apertures
aper_ann = [apertures, annulus]
phot_table = aperture_photometry(imdata, aper_ann)
# Find the background per pixel from the annulus
print('\nMean background per pixel:')
phot_table['mean_bkg'] = phot_table['aperture_sum_1'] / annulus.area
phot_table['id', 'mean_bkg'].pprint()
# Compute the background signal contribution to the aperture
bkg_signal = phot_table['mean_bkg'] * apertures.area
source_counts = phot_table['aperture_sum_0'] - bkg_signal
# Compute the flux and instrumental magnitude and add info to phot_table
count_rate = source_counts / imheader['EXPTIME'] # count_rate in ADU/sec
mag = get_magnitude(count_rate)
phot_table['count_rate'] = count_rate
def extract_ifu(input_model, source_type, extract_params):
"""This function does the extraction.
Parameters
----------
input_model : IFUCubeModel
The input model.
source_type : string
"POINT" or "EXTENDED"
extract_params : dict
The extraction parameters for aperture photometry.
Returns
-------
ra, dec : float
ra and dec are the right ascension and declination respectively
at the nominal center of the image.
wavelength : ndarray, 1-D
The wavelength in micrometers at each plane of the IFU cube.
temp_flux : ndarray, 1-D
The sum of the data values in the extraction aperture minus the
sum of the data values in the background region (scaled by the
ratio of areas), for each plane.
The data values are in units of surface brightness, so this value
isn't really the flux, it's an intermediate value. Dividing by
`npixels` (to compute the average) will give the value for the
`surf_bright` (surface brightness) column, and multiplying by
the solid angle of a pixel will give the flux for a point source.
background : ndarray, 1-D
For point source data, the background array is the count rate that was subtracted
from the total source data values to get `temp_flux`. This background is determined
for annulus region. For extended source data, the background array is the sigma clipped
extracted region.
npixels : ndarray, 1-D, float64
For each slice, this is the number of pixels that were added
together to get `temp_flux`.
dq : ndarray, 1-D, uint32
The data quality array.
npixels_bkg : ndarray, 1-D, float64
For each slice, for point source data this is the number of pixels that were added
together to get `temp_flux` for an annulus region or for extended source
data it is the number of pixels used to determine the background
radius_match : ndarray,1-D, float64
The size of the extract radius in pixels used at each wavelength of the IFU cube
x_center, y_center : float
The x and y center of the extraction region
"""
data = input_model.data
weightmap = input_model.weightmap
shape = data.shape
if len(shape) != 3:
log.error("Expected a 3-D IFU cube; dimension is %d.", len(shape))
raise RuntimeError("The IFU cube should be 3-D.")
# We need to allocate temp_flux, background, npixels, and dq arrays
# no matter what. We may need to divide by npixels, so the default
# is 1 rather than 0.
temp_flux = np.zeros(shape[0], dtype=np.float64)
background = np.zeros(shape[0], dtype=np.float64)
npixels = np.ones(shape[0], dtype=np.float64)
npixels_bkg = np.ones(shape[0], dtype=np.float64)
dq = np.zeros(shape[0], dtype=np.uint32)
# For an extended target, the entire aperture will be extracted, so
# it makes no sense to shift the extraction location.
if source_type != "EXTENDED":
ra_targ = input_model.meta.target.ra
dec_targ = input_model.meta.target.dec
locn = locn_from_wcs(input_model, ra_targ, dec_targ)
if locn is None or np.isnan(locn[0]):
log.warning("Couldn't determine pixel location from WCS, so "
"source offset correction will not be applied.")
x_center = float(shape[-1]) / 2.
y_center = float(shape[-2]) / 2.
else:
(x_center, y_center) = locn
log.info(
"Using x_center = %g, y_center = %g, based on "
"TARG_RA and TARG_DEC.", x_center, y_center)
method = extract_params['method']
subpixels = extract_params['subpixels']
subtract_background = extract_params['subtract_background']
radius = None
inner_bkg = None
outer_bkg = None
width = None
height = None
theta = None
# pull wavelength plane out of input data.
# using extract 1d wavelength, interpolate the radius, inner_bkg, outer_bkg to match input wavelength
# find the wavelength array of the IFU cube
x0 = float(shape[2]) / 2.
y0 = float(shape[1]) / 2.
(ra, dec, wavelength) = get_coordinates(input_model, x0, y0)
# interpolate the extraction parameters to the wavelength of the IFU cube
radius_match = None
if source_type == 'POINT':
wave_extract = extract_params['wavelength'].flatten()
inner_bkg = extract_params['inner_bkg'].flatten()
outer_bkg = extract_params['outer_bkg'].flatten()
radius = extract_params['radius'].flatten()
frad = interp1d(wave_extract,
radius,
bounds_error=False,
fill_value="extrapolate")
radius_match = frad(wavelength)
# radius_match is in arc seconds - need to convert to pixels
# the spatial scale is the same for all wavelengths do we only need to call compute_scale once.
if locn is None:
locn_use = (input_model.meta.wcsinfo.crval1,
input_model.meta.wcsinfo.crval2, wavelength[0])
else:
locn_use = (ra_targ, dec_targ, wavelength[0])
scale_degrees = compute_scale(
input_model.meta.wcs,
locn_use,
disp_axis=input_model.meta.wcsinfo.dispersion_direction)
scale_arcsec = scale_degrees * 3600.00
radius_match /= scale_arcsec
finner = interp1d(wave_extract,
inner_bkg,
bounds_error=False,
fill_value="extrapolate")
inner_bkg_match = finner(wavelength) / scale_arcsec
fouter = interp1d(wave_extract,
outer_bkg,
bounds_error=False,
fill_value="extrapolate")
outer_bkg_match = fouter(wavelength) / scale_arcsec
elif source_type == 'EXTENDED':
# Ignore any input parameters, and extract the whole image.
width = float(shape[-1])
height = float(shape[-2])
x_center = width / 2. - 0.5
y_center = height / 2. - 0.5
theta = 0.
subtract_background = False
bkg_sigma_clip = extract_params['bkg_sigma_clip']
log.debug("IFU 1-D extraction parameters:")
log.debug(" x_center = %s", str(x_center))
log.debug(" y_center = %s", str(y_center))
if source_type == 'POINT':
log.debug(" method = %s", method)
if method == "subpixel":
log.debug(" subpixels = %s", str(subpixels))
else:
log.debug(" width = %s", str(width))
log.debug(" height = %s", str(height))
log.debug(" theta = %s degrees", str(theta))
log.debug(" subtract_background = %s", str(subtract_background))
log.debug(" sigma clip value for background = %s",
str(bkg_sigma_clip))
log.debug(" method = %s", method)
if method == "subpixel":
log.debug(" subpixels = %s", str(subpixels))
position = (x_center, y_center)
# get aperture for extended it will not change with wavelength
if source_type == 'EXTENDED':
aperture = RectangularAperture(position, width, height, theta)
annulus = None
for k in range(shape[0]): # looping over wavelength
inner_bkg = None
outer_bkg = None
if source_type == 'POINT':
radius = radius_match[
k] # this radius has been converted to pixels
aperture = CircularAperture(position, r=radius)
inner_bkg = inner_bkg_match[k]
outer_bkg = outer_bkg_match[k]
if inner_bkg <= 0. or outer_bkg <= 0. or inner_bkg >= outer_bkg:
log.debug("Turning background subtraction off, due to "
"the values of inner_bkg and outer_bkg.")
subtract_background = False
if subtract_background and inner_bkg is not None and outer_bkg is not None:
annulus = CircularAnnulus(position,
r_in=inner_bkg,
r_out=outer_bkg)
else:
annulus = None
subtract_background_plane = subtract_background
# Compute the area of the aperture and possibly also of the annulus.
# for each wavelength bin (taking into account empty spaxels)
normalization = 1.
temp_weightmap = weightmap[k, :, :]
temp_weightmap[temp_weightmap > 1] = 1
aperture_area = 0
annulus_area = 0
# aperture_photometry - using weight map
phot_table = aperture_photometry(temp_weightmap,
aperture,
method=method,
subpixels=subpixels)
aperture_area = float(phot_table['aperture_sum'][0])
log.debug("aperture.area = %g; aperture_area = %g", aperture.area,
aperture_area)
if (aperture_area == 0 and aperture.area > 0):
aperture_area = aperture.area
if subtract_background and annulus is not None:
# Compute the area of the annulus.
phot_table = aperture_photometry(temp_weightmap,
annulus,
method=method,
subpixels=subpixels)
annulus_area = float(phot_table['aperture_sum'][0])
log.debug("annulus.area = %g; annulus_area = %g", annulus.area,
annulus_area)
if (annulus_area == 0 and annulus.area > 0):
annulus_area = annulus.area
if annulus_area > 0.:
normalization = aperture_area / annulus_area
else:
log.warning("Background annulus has no area, so background "
f"subtraction will be turned off. {k}")
subtract_background_plane = False
npixels[k] = aperture_area
npixels_bkg[k] = 0.0
if annulus is not None:
npixels_bkg[k] = annulus_area
# aperture_photometry - using data
phot_table = aperture_photometry(data[k, :, :],
aperture,
method=method,
subpixels=subpixels)
temp_flux[k] = float(phot_table['aperture_sum'][0])
# Point source type of data with defined annulus size
if subtract_background_plane:
bkg_table = aperture_photometry(data[k, :, :],
annulus,
method=method,
subpixels=subpixels)
background[k] = float(bkg_table['aperture_sum'][0])
temp_flux[k] = temp_flux[k] - background[k] * normalization
# Extended source data - background determined from sigma clipping
if source_type == 'EXTENDED':
bkg_data = data[k, :, :]
# pull out the data with coverage in IFU cube. We do not want to use
# the edge data that is zero to define the statistics on clipping
bkg_stat_data = bkg_data[temp_weightmap == 1]
bkg_mean, _, bkg_stddev = stats.sigma_clipped_stats(
bkg_stat_data, sigma=bkg_sigma_clip, maxiters=5)
low = bkg_mean - bkg_sigma_clip * bkg_stddev
high = bkg_mean + bkg_sigma_clip * bkg_stddev
# set up the mask to flag data that should not be used in aperture photometry
maskclip = np.logical_or(bkg_data < low, bkg_data > high)
bkg_table = aperture_photometry(bkg_data,
aperture,
mask=maskclip,
method=method,
subpixels=subpixels)
background[k] = float(bkg_table['aperture_sum'][0])
phot_table = aperture_photometry(temp_weightmap,
aperture,
mask=maskclip,
method=method,
subpixels=subpixels)
npixels_bkg[k] = float(phot_table['aperture_sum'][0])
del temp_weightmap
# done looping over wavelength bins
# Check for NaNs in the wavelength array, flag them in the dq array,
# and truncate the arrays if NaNs are found at endpoints (unless the
# entire array is NaN).
(wavelength, temp_flux, background, npixels, dq, npixels_bkg) = \
nans_in_wavelength(wavelength, temp_flux, background, npixels, dq, npixels_bkg)
return (ra, dec, wavelength, temp_flux, background, npixels, dq,
npixels_bkg, radius_match, x_center, y_center)
def ConCur(star_data,
radius_size=1,
center=None,
background_method='astropy',
find_hots=False,
find_center=False):
data = star_data.copy()
background_mean, background_std = background_calc(data, background_method)
x, y = np.indices((data.shape))
if not center:
center = np.array([(x.max() - x.min()) / 2.0,
(y.max() - y.min()) / 2.0])
if find_hots == True:
hots = hot_pixels(data, center, background_mean, background_std)
if find_center == True:
center_vals = find_best_center(data, radius_size, center)
center = np.array([center_vals[0], center_vals[1]])
radii = np.sqrt((x - center[0])**2 + (y - center[1])**2)
radii = radii.astype(np.int)
ones = np.array([[1] * len(data)] * len(data[0]))
number_of_a = radii.max() / radius_size
center_ap = CircularAperture([center[0], center[1]], radius_size)
all_apers, all_apers_areas, all_masks = [center_ap], [center_ap.area], [
center_ap.to_mask(method='exact')
]
all_data, all_weights = [all_masks[0].multiply(data)
], [all_masks[0].multiply(ones)]
all_stds = [twoD_weighted_std(all_data[0], all_weights[0])]
for j in range(int(number_of_a)):
aper = CircularAnnulus([center[0], center[1]],
r_in=(j * radius_size + radius_size),
r_out=(j * radius_size + 2 * radius_size))
all_apers.append(aper)
all_apers_areas.append(aper.area)
mask = aper.to_mask(method='exact')
all_masks.append(mask)
mask_data = mask.multiply(data)
mask_weight = mask.multiply(ones)
all_data.append(mask_data)
all_weights.append(mask_weight)
all_stds.append(twoD_weighted_std(mask_data, mask_weight))
phot_table = aperture_photometry(data, all_apers)
center_val = np.sum(all_data[0]) / all_apers_areas[0] + 5 * all_stds[0]
delta_mags = []
for i in range(len(phot_table[0]) - 3):
try:
delta_mags.append(-2.5 * math.log((np.sum(all_data[i])/all_apers_areas[i] + \
5*all_stds[i])/center_val,10))
except ValueError:
print('annulus',i, 'relative flux equal to', (np.sum(all_data[i])/all_apers_areas[i] + \
5*all_stds[i])/center_val, '...it is not included')
delta_mags.append(np.NaN)
arc_lengths = []
for i in range(len(delta_mags)):
arc_lengths.append(
(i * 0.033 + 0.033) *
radius_size) #make sure center radius size is correct
arc_lengths = np.array(arc_lengths)
lim_arc_lengths = arc_lengths[arc_lengths < 10]
delta_mags = delta_mags[:len(lim_arc_lengths)]
delta_mags = np.array(delta_mags)
if delta_mags[1] < 0:
print('Warning: first annulus has negative relative flux of value,',
'%.5f' % delta_mags[1],
'consider changing center or radius size')
return (lim_arc_lengths, delta_mags, all_stds)
pixelCenter = (155.888, 139.095)
arcsecsInAPixel = hdu.header['CDELT2'] * 3600
#arsecondRadius = 0.1
pixelRadius = 8
data = hdu.data
wcsCube = WCS(hdu.header, naxis=3)
restFrequency = hdu.header['RESTFRQ']
apertures = getCircularApetures(pixelCenter, pixelRadius)
fluxes = []
for aperture in apertures:
fluxes.append([
list(aperture_photometry(data[0][val], aperture)['aperture_sum'])[0]
for val in range(len(data[0]))
])
x = np.arange(len(data[0]))
_, _, freqs = wcsCube.pixel_to_world_values(x, x, x)
vels = 300000 * ((-freqs + restFrequency) / restFrequency)
for i in range(7):
f = open(f'nice_circle{i+1}.txt', 'w')
for j in range(len(x)):
f.write(f'{vels[j]} {fluxes[i][j]} \n')
f.close()
#####################################################################################
infiles = []
read_file(str(sys.argv[2]), "ROTATION"))
data_bkg_mean = radial_data_mean(data[0])
c = plt.imshow(data_bkg_mean, interpolation='nearest', origin='lower')
plt.colorbar(c)
plt.title('backgraound flux of target science')
plt.show()
#hdu = fits.PrimaryHDU(res_cADI)
#hdu.writeto("./GJ_667C_origin_rotated.fits")
positions = [(126.05284, 249.11)]
#positions = [(143.06025, 166.01939)]
aperture = CircularAperture(positions, r=2)
annulus = CircularAnnulus(positions, r_in=4, r_out=6)
#data[0][1:,1:] = data[0][1:,1:] - data_bkg_mean
flux_companion = aperture_photometry(data[0], [aperture, annulus])
bkg_mean = flux_companion['aperture_sum_1'] / annulus.area
bkg_sum_in_companion = bkg_mean * aperture.area
print(flux_companion)
print("bkg_mean =", bkg_mean[0], "\naperture.area =", aperture.area,
"\nannulus.area =", annulus.area)
print("bkg_sum_in_companion =", bkg_sum_in_companion[0])
flux_companion_origin = flux_companion[
'aperture_sum_0'] - bkg_sum_in_companion
print("flux companion origin =", flux_companion_origin[0])
norm = simple_norm(data, 'sqrt', percent=99)
plt.imshow(data[0], norm=norm, interpolation='nearest')
ap_patches = aperture.plot(color='white',
lw=2,
def apt_phot(images, source_reg, background_reg=None, apt_corr=1):
#if the image is unique we convert it to a list to keep the next loop
#unchanged
if type(images) == str:
images = [images]
for image_file in images:
if os.path.isfile(image_file):
hst_hdul = fits.open(image_file)
date = hst_hdul[0].header["DATE-OBS"]
if "FILTER" in hst_hdul[0].header:
hst_filter = hst_hdul[0].header["FILTER"]
elif "FILTER1" in hst_hdul[0].header:
hst_filter = hst_hdul[0].header["FILTER1"]
else:
hst_filter = hst_hdul[0].header["FILTNAM1"]
instrument = hst_hdul[0].header["INSTRUME"]
if "BUNIT" in hst_hdul[0].header:
if hst_hdul[0].header["BUNIT"] == '':
print('no unit-assuming ELECTRONS/S')
units = 'ELECTRONS/S'
else:
units = hst_hdul[0].header["BUNIT"]
elif "BUNIT" in hst_hdul[1].header:
if hst_hdul[1].header["BUNIT"] == '':
print('no unit-assuming ELECTRONS/S')
units = 'ELECTRONS/S'
else:
units = hst_hdul[1].header["BUNIT"]
exp_time = float(hst_hdul[0].header["EXPTIME"])
detector = hst_hdul[0].header[
"DETECTOR"] if "DETECTOR" in hst_hdul[0].header else ""
if "PHOTPLAM" in hst_hdul[0].header:
pivot_wavelength = float(hst_hdul[0].header["PHOTPLAM"])
elif "PHOTPLAM" in hst_hdul[1].header:
pivot_wavelength = float(hst_hdul[1].header["PHOTPLAM"])
if "PHOTBW" in hst_hdul[0].header:
filter_bandwidth = float(hst_hdul[0].header["PHOTBW"])
elif "PHOTBW" in hst_hdul[1].header:
filter_bandwidth = float(hst_hdul[1].header["PHOTBW"])
# if UV filter then https://www.stsci.edu/files/live/sites/www/files/home/hst/instrumentation/wfc3/documentation/instrument-science-reports-isrs/_documents/2017/WFC3-2017-14.pdf
# use phftlam1 keyword for UV filters
uv_filters = [
"F200LP", "F300X", "F218W", "F225W", "F275W", "FQ232N",
"FQ243N", "F280N"
]
if detector == "UVIS" and filter in uv_filters:
photflam = float(hst_hdul[0].header["PHTFLAM1"])
elif "PHOTFLAM" in hst_hdul[0].header:
photflam = float(hst_hdul[0].header["PHOTFLAM"])
elif "PHOTFLAM" in hst_hdul[1].header:
photflam = float(hst_hdul[1].header["PHOTFLAM"])
print("PHOTFLAM keyword value: %.2E" % photflam)
if "PHOTZPT" in hst_hdul[0].header:
zero_point = float(hst_hdul[0].header["PHOTZPT"])
elif "PHOTZPT" in hst_hdul[1].header:
zero_point = float(hst_hdul[1].header["PHOTZPT"])
if len(hst_hdul) == 1:
image_data = hst_hdul[0].data
wcs = WCS(hst_hdul[0].header)
else:
image_data = hst_hdul[1].data
wcs = WCS(hst_hdul[1].header)
source_aperture = region_to_aperture(source_reg, wcs)
print(source_aperture)
bkg_aperture = region_to_aperture(background_reg, wcs)
phot_source = aperture_photometry(image_data, source_aperture)
if background_reg is not None:
phot_bkg = aperture_photometry(image_data, bkg_aperture)
# background correction
phot_source["corrected_aperture"] = phot_source[
"aperture_sum"] - phot_bkg[
"aperture_sum"] / bkg_aperture.area * source_aperture.area
phot_source["corrected_aperture_err"] = sqrt(
phot_source["aperture_sum"] +
(sqrt(phot_bkg["aperture_sum"]) / bkg_aperture.area *
source_aperture.area)**2)
phot_source_conf = phot_source[
"corrected_aperture"] + phot_source[
"corrected_aperture_err"]
phot_source_conf_neg = phot_source[
"corrected_aperture"] - phot_source[
"corrected_aperture_err"]
else:
phot_source["corrected_aperture"] = phot_source["aperture_sum"]
phot_source["corrected_aperture_err"] = 0
phot_source_conf = phot_source[
"corrected_aperture"] + phot_source[
"corrected_aperture_err"]
phot_source_conf_neg = phot_source[
"corrected_aperture"] - phot_source[
"corrected_aperture_err"]
# divide by the exposure time if needed
if "/S" in units:
print(
"Units: %s. Exposure time correction will not be applied" %
units)
phot_source["flux"] = phot_source[
"corrected_aperture"] / apt_corr * photflam
phot_source[
"flux_err"] = phot_source_conf / apt_corr * photflam - phot_source[
"flux"]
if phot_source["corrected_aperture"] > 0:
phot_source["mag"] = -2.5 * log10(
phot_source["corrected_aperture"] /
apt_corr) - zero_point
phot_source["mag_err_neg"] = -2.5 * log10(
phot_source_conf /
apt_corr) - zero_point - phot_source["mag"]
else:
phot_source["mag"] = 'Nan.'
phot_source["mag_err_neg"] = 'Nan.'
if phot_source_conf_neg > 0:
phot_source["mag_err_pos"] = -2.5 * log10(
phot_source_conf_neg /
apt_corr) - zero_point - phot_source["mag"]
else:
phot_source["mag_err_pos"] = 'Nan.'
else:
print("Units: %s. Applying exposure time correction" % units)
phot_source["flux"] = phot_source[
"corrected_aperture"] / apt_corr * photflam / exp_time
phot_source[
"flux_err"] = phot_source_conf / apt_corr * photflam / exp_time - phot_source[
"flux"]
if phot_source["corrected_aperture"] > 0:
phot_source["mag"] = -2.5 * log10(
phot_source["corrected_aperture"] / apt_corr /
exp_time) - zero_point
phot_source["mag_err_neg"] = -2.5 * log10(
phot_source_conf / apt_corr /
exp_time) - zero_point - phot_source["mag"]
else:
phot_source["mag"] = 'Nan.'
phot_source["mag_err_neg"] = 'Nan.'
if phot_source_conf_neg > 0:
phot_source["mag_err_pos"] = -2.5 * log10(
phot_source_conf_neg / apt_corr /
exp_time) - zero_point - phot_source["mag"]
else:
phot_source["mag_err_pos"] = 'Nan.'
phot_source['flux'].info.format = '%.3E'
phot_source['flux_err'].info.format = '%.3E'
if phot_source["mag"] != 'Nan.':
phot_source["mag"].info.format = "%.3f"
if phot_source["mag_err_neg"] != 'Nan.':
phot_source["mag_err_neg"].info.format = "%.3f"
if phot_source["mag_err_pos"] != 'Nan.':
phot_source["mag_err_pos"].info.format = "%.3f"
os.system('mkdir -p photometry')
os.chdir('photometry')
phot_source.write("aperture_photometry.csv", overwrite=True)
output = np.array(
pd.read_csv("aperture_photometry.csv", delimiter=','))[0]
os.chdir('..')
return (output)
if detector == "UVIS" and filter in uv_filters:
photflam = float(hst_hdul[0].header["PHTFLAM1"])
elif "PHOTFLAM" in hst_hdul[0].header:
photflam = float(hst_hdul[0].header["PHOTFLAM"])
elif "PHOTFLAM" in hst_hdul[1].header:
photflam = float(hst_hdul[1].header["PHOTFLAM"])
photflam = photflam * u.erg / u.AA / u.s / u.cm**2
print("PHOTFLAM keyword value: %.2E %s" % (photflam.value, photflam.unit))
zero_point = float(hst_hdul[1].header["PHOTZPT"])
image_data = hst_hdul[1].data
hst_wcs = wcs.WCS(hst_hdul[1].header)
source_aperture = hst_ut.region_to_aperture(source_reg, hst_wcs)
mask = image_data < 0
phot_source = aperture_photometry(image_data, source_aperture, error=np.sqrt(image_data * exp_time) / exp_time, wcs=hst_wcs, mask=mask)
source_area = source_aperture.area
aperture_keyword = "corrected_aperture_sum(%s)" % units
if args.exclude is not None:
for exclude_reg in Regions.read(args.exclude, format="ds9"):
exclude_aperture = hst_ut.region_to_aperture(exclude_reg, hst_wcs)
phot_exclude = aperture_photometry(image_data, exclude_aperture, wcs=hst_wcs, error=np.sqrt(image_data * exp_time) / exp_time, mask=mask)
source_area -= exclude_aperture.area
phot_source["aperture_sum_err"] = np.sqrt(phot_exclude["aperture_sum_err"] ** 2 + phot_source["aperture_sum_err"] ** 2)
phot_source["aperture_sum"] -= phot_exclude["aperture_sum"]
# if a background region was given
if len(regions) > 1:
bkg_reg = regions[1]
bkg_aperture = hst_ut.region_to_aperture(bkg_reg, hst_wcs)
# RC3: R_25 ~ 234 arcsec Rc=234 nn = Rc/a nna = nn*a nnb = nn*b phi = angles_in_ellipse(40, nna, nnb) #print(np.round(np.rad2deg(phi), 2)) e = (1.0 - nnb ** 2.0 / nna ** 2.0) ** 0.5 arcs = sp.special.ellipeinc(phi, e) #print(np.round(np.diff(arcs), 4)) x = cat.xcentroid + nnb * np.sin(phi) y = cat.ycentroid + nna * np.cos(phi) box = RectangularAperture(zip(x,y), 32, 32) boolmask = box_cutout.data > 0 phot = aperture_photometry(data, box, mask=boolmask) bkg_mean = np.mean(phot['aperture_sum'] / box.area) # 14.985152614520166 bkg_rms = np.std(phot['aperture_sum'] / box.area) # 4.568966255984001 plt.figure(figsize=(8, 8)) norm = simple_norm(data*~boolmask, 'sqrt', percent=99.) im=plt.imshow(data*~boolmask, cmap='viridis',interpolation='nearest',norm=norm) plt.colorbar(im) aperture.plot(color='#d62728') box.plot(color='#d62728') print(bkg_mean,bkg_rms,bkg_mean - 1*bkg_rms,bkg_mean + 1*bkg_rms,bkg_mean - 3*bkg_rms,bkg_mean + 3*bkg_rms) #data = data - (bkg_mean+3*bkg_rms)#(bkg_mean - 1*bkg_rms) ### np.median(data[box_cutout.data==0]) # == 15.167292 ### np.std(data[box_cutout.data==0]) #== 10.078673 # ---------------------------------------------------------------------------- #datamask = deepcopy(data) #datamask[mask>0]=0
def iraf_style_photometry(phot_apertures,
bg_apertures,
data,
photflam,
photplam,
error_array=None,
bg_method='mode',
epadu=1.0):
"""
Computes photometry with PhotUtils apertures, with IRAF formulae
Parameters
----------
phot_apertures : photutils PixelAperture object (or subclass)
The PhotUtils apertures object to compute the photometry. i.e. the object returned via CirularAperture.
bg_apertures : photutils PixelAperture object (or subclass)
The phoutils aperture object to measure the background in. i.e. the object returned via CircularAnnulus.
data : array
The data for the image to be measured.
photflam : float
inverse sensitivity, in ergs/cm2/angstrom/electron
photplam : float
Pivot wavelength, in angstroms
error_array : array
(Optional) The array of pixelwise error of the data. If none, the Poisson noise term in the error computation
will just be the square root of the flux/epadu. If not none, the aperture_sum_err column output by
aperture_photometry (divided by epadu) will be used as the Poisson noise term.
bg_method: string
{'mean', 'median', 'mode'}, optional. The statistic used to calculate the background. All measurements are
sigma clipped. Default value is 'mode'. NOTE: From DAOPHOT, mode = 3 * median - 2 * mean.
epadu : float
(optional) Gain in electrons per adu (only use if image units aren't e-). Default value is 1.0
Returns
-------
An astropy Table with columns as follows:
X-Center Y-Center RA DEC ID MagAp1 MagErrAp1 MagAp2 MagErrAp2 MSkyAp2 StdevAp2 FluxAp2 CI Flags
"""
if bg_method not in ['mean', 'median', 'mode']:
raise ValueError('Invalid background method, choose either \
mean, median, or mode')
phot = aperture_photometry(data, phot_apertures, error=error_array)
bg_phot = aperture_stats_tbl(data, bg_apertures, sigma_clip=True)
names = ['X-Center', 'Y-Center', 'ID']
x, y = phot_apertures[0].positions.T
final_stacked = np.stack([x, y, phot["id"].data], axis=1)
# n_aper = 0
name_list = 'Flux', 'FluxErr', 'Mag', 'MagErr'
for aper_string in ['Ap1', 'Ap2']:
for col_name in name_list:
names.append("{}{}".format(col_name, aper_string))
# for item in list(phot.keys()):
# if item.startswith("aperture_sum_") and not item.startswith("aperture_sum_err_"):
# aper_size_arcsec = phot_apertures[n_aper].r * platescale
# for name in name_list:
# names.append("{}_{:.2f}".format(name, aper_size_arcsec))
# n_aper += 1
for aperCtr in range(0, 2):
ap_area = phot_apertures[aperCtr].area
bg_method_name = 'aperture_{}'.format(bg_method)
flux = phot['aperture_sum_{}'.format(
aperCtr)] - bg_phot[bg_method_name] * ap_area
# Need to use variance of the sources
# for Poisson noise term in error computation.
#
# This means error needs to be squared.
# If no error_array error = flux ** .5
if error_array is not None:
flux_error = compute_phot_error(
phot['aperture_sum_err_{}'.format(aperCtr)]**2.0, bg_phot,
bg_method, ap_area, epadu)
else:
flux_error = compute_phot_error(flux, bg_phot, bg_method, ap_area,
epadu)
mag = convert_flux_to_abmag(flux, photflam, photplam)
# NOTE: Magnitude error calculation comes from computing d(ABMAG)/d(flux).
# See https://iraf.net/forum/viewtopic.php?showtopic=83932 for details.
mag_err = 1.0857 * flux_error / flux
# Build the final data table
stacked = np.stack([flux, flux_error, mag, mag_err], axis=1)
final_stacked = np.concatenate([final_stacked, stacked], axis=1)
# Build final output table
final_tbl = Table(data=final_stacked,
names=names,
dtype=[
np.float64, np.float64, np.int64, np.float64,
np.float64, np.float64, np.float64, np.float64,
np.float64, np.float64, np.float64
])
# add sky and std dev columns from background calculation subroutine
final_tbl.add_column(bg_phot[bg_method_name])
final_tbl.rename_column(bg_method_name, 'MSkyAp2')
final_tbl.add_column(bg_phot['aperture_std'])
final_tbl.rename_column('aperture_std', 'StdevAp2')
return final_tbl
