def first_cc_val_neg(param, *args): center_x, center_y = param data = args[0] radius_size = args[1] ones = np.array([[1] * 600] * 600) center_ap = CircularAperture([center_x, center_y], radius_size) center_area = center_ap.area center_mask = center_ap.to_mask(method='exact') center_data = center_mask.multiply(data) center_weights = center_mask.multiply(ones) center_std = twoD_weighted_std(center_data, center_weights) center_val = (np.sum(center_data)) / center_area + 5 * center_std first_ap = CircularAnnulus([center_x, center_y], r_in=radius_size, r_out=2 * radius_size) first_area = first_ap.area first_mask = first_ap.to_mask(method='exact') first_data = first_mask.multiply(data) first_weights = first_mask.multiply(ones) first_std = twoD_weighted_std(first_data, first_weights) first_val = (np.sum(first_data)) / first_area + 5 * first_std result = (-2.5 * math.log(first_val / center_val, 10)) return -1 * (result)
def _filter_images(data, hmin): """Performs filtering/convolution on images for source finding""" #Laziest way to get a circle mask fp = CircularAperture((0, 0), r=hmin).to_mask().data > .1 fp = fp.astype(bool) # Apply maximum filter, flux filter filt_image = maximum_filter(data, footprint=fp, mode='constant', cval=0) origins = product([0, -1], [0, -1]) max_4sum = np.amax([_conv_origin(data, o) for o in origins], axis=0) return (filt_image, max_4sum)
def _setup_cutout(self, data): """Cuts out the aperture and defines slice objects. General setup procedure. """ self.ap = CircularAperture((self.x, self.y), r=self.r) mask = self.ap.to_mask()[0] self.sy = mask.bbox.slices[0] self.sx = mask.bbox.slices[1] self.cutout = mask.cutout(data, fill_value=np.nan) if self.cutout is None: self.is_empty = True
def plotTestImage(imageArray): interval = ZScaleInterval() limits = interval.get_limits(imageArray) sources = locateStarsInImage(imageArray) positions = np.transpose((sources['xcentroid'], sources['ycentroid'])) apertures = CircularAperture(positions, r=4.) norm = ImageNormalize(stretch=SqrtStretch()) plt.imshow(imageArray, cmap='Greys', origin='lower', norm=norm, interpolation='nearest', vmin=limits[0], vmax=limits[1]) apertures.plot(color='red', lw=1.5, alpha=0.5) plt.show()
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 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 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 allreg_to_aperture(region): """Convert region object to aperture object.""" region_type = type(region).__name__ if "Pixel" in region_type: source_center = (region.center.x, region.center.y) if region_type == 'CirclePixelRegion': return CircularAperture(source_center, r=region.radius) elif region_type == "CircleAnnulusPixelRegion": return CircularAnnulus(source_center, r_in=region.inner_radius, r_out=region.outer_radius) elif region_type == "EllipsePixelRegion": # to be tested return EllipticalAperture(source_center, a=region.width, b=region.height, angle=region.angle) elif "Sky" in region_type: center = region.center.fk5 if region_type == "CircleSkyRegion": return SkyCircularAperture(center, r=region.radius) elif region_type == "EllipseSkyRegion": return SkyEllipticalAperture(center, a=region.width / 2, b=region.height / 2, angle=region.angle) elif region_type == "CircleAnnulusSkyRegion": return SkyCircularAnnulus(center, r_in=region.inner_radius, r_out=region.outer_radius) else: print("Error region not implemented") return None
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 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 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 compute_circular_aperture(self, centre, radius, flux_return=False, plot=False): from photutils.aperture import CircularAperture#, aperture_photometry aperture = CircularAperture(centre, r=radius) aperture_mask = aperture.to_mask() aperture_mask = np.array( aperture_mask.to_image(self.wcs.celestial.array_shape), dtype=bool) if flux_return: integrated_flux = np.nansum(self.flux[:, aperture_mask], axis=1) integrated_no_cov = np.nansum(self.flux_error[:, aperture_mask]**2, axis=1) ## Accounting for covariance errors if aperture_mask[aperture_mask].size<100: integrated_flux_cov = integrated_no_cov*( 1+1.62*np.log10(aperture_mask[aperture_mask].size)) integrated_flux_err = np.sqrt(integrated_flux_cov) else: integrated_flux_cov = integrated_no_cov*4.2 integrated_flux_err = np.sqrt(integrated_flux_cov) else: integrated_flux = None integrated_flux_err = None if plot: fig = plt.figure() ax = fig.add_subplot(111) ax.imshow(self.flux[self.wl.size//2, :, :], cmap='gist_earth_r') aperture.plot(lw=1, color='r') ax.annotate(r'$R_e={:4.3}~(Kpc)$'.format(self.eff_radius_physical), xy=(.9,.95), xycoords='axes fraction', va='top', ha='right') ax.annotate(r'$R_e={:4.3}~(arcsec)$'.format(self.eff_radius), xy=(.9,.9), xycoords='axes fraction', va='top', ha='right') aperture.plot(lw=1, color='r') ax.annotate(r'$R_e={:4.3}~(pix)$'.format(self.eff_radius_pix), xy=(.9,.85), xycoords='axes fraction', va='top', ha='right') ax.annotate(r'$R_a={:4.3}~(pix)$'.format(radius), xy=(.9,.80), xycoords='axes fraction', va='top', ha='right', color='r') aperture.plot(lw=1, color='r') # plt.savefig('bpt_apertures/'+name_i+'.png') plt.show() plt.close() return aperture, aperture_mask, integrated_flux, integrated_flux_err, fig else: return aperture, aperture_mask, integrated_flux, integrated_flux_err
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_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 region_to_aperture(region, wcs=None): """Convert region object to photutils.aperture.aperture_photometry object. The wcs object is needed only if the input regions are in sky coordinates. Parameters ---------- region: regions.Region Output of read_ds9 method or str wcs: astropy.wcs.WCS A world coordinate system if the region in sky coordinates IS needed to convert it to pixels. """ if type(region) == str: region = read_ds9(region)[0] print(region) region_type = type(region).__name__ if "Pixel" in region_type: source_center = (region.center.x, region.center.y) if region_type == 'CirclePixelRegion': return CircularAperture(source_center, r=region.radius) elif region_type == "CircleAnnulusPixelRegion": return CircularAnnulus(source_center, r_in=region.inner_radius, r_out=region.outer_radius) elif region_type == "EllipsePixelRegion": # to be tested return EllipticalAperture(source_center, a=region.width, b=region.height, theta=region.angle) elif "Sky" in region_type: if wcs is None: print("Error, cannot obtain aperture without a wcs.") return None center = region.center.fk5 if region_type == "CircleSkyRegion": return SkyCircularAperture(center, r=region.radius).to_pixel(wcs) elif region_type == "CircleAnnulusSkyRegion": print("Region %s not implemented") elif region_type == "EllipseSkyRegion": return SkyEllipticalAperture(center, a=region.width, b=region.height, theta=region.angle).to_pixel(wcs) elif region_type == "CircleAnnulusSkyRegion": return SkyCircularAnnulus(center, r_in=region.inner_radius, r_out=region.outer_radius).to_pixel(wcs) else: print("Error region not implemented") return None
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)
# 3. result of cADI data = origin_flux_companion( slice_frame(target_frames, len(target_frames[0, 0, 0]), scale), 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])
#%% find the sources daofind = DAOStarFinder(fwhm=seeing, sky=median, threshold=5. * std) sources = daofind.find_stars(imdata - median) print('\nPrint source locations:') sources['id', 'xcentroid', 'ycentroid'].pprint() #print out positions of sources print('\n') #%% perform aperture photometry # extract source postions from table; transpose is needed for proper orientation positions = np.transpose((sources['xcentroid'], sources['ycentroid'])) # define the aperture r_a = 3 * seeing apertures = CircularAperture(positions, r=r_a) # define the annulus r_in = r_a + 3 r_out = r_in + 15 annulus = CircularAnnulus(positions, r_in=r_in, r_out=r_out) # plot image with apertures y_or_n = input('Do you wish to display the image and appertures? ') if (y_or_n[0] == 'y') or (y_or_n[0] == 'Y'): 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]))
def tso_aperture_photometry(datamodel, xcenter, ycenter, radius, radius_inner, radius_outer): """ Create a photometric catalog for NIRCam TSO imaging observations. Parameters ---------- datamodel : `CubeModel` The input `CubeModel` of a NIRCam TSO imaging observation. xcenter, ycenter : float The ``x`` and ``y`` center of the aperture. radius : float The radius (in pixels) of the circular aperture. radius_inner, radius_outer : float The inner and outer radii (in pixels) of the circular-annulus aperture, used for local background estimation. Returns ------- catalog : `~astropy.table.QTable` An astropy QTable (Quantity Table) containing the source photometry. """ if not isinstance(datamodel, CubeModel): raise ValueError('The input data model must be a CubeModel.') # For the SUB64P subarray with the WLP8 pupil, the circular aperture # extends beyond the image and the circular annulus does not have any # overlap with the image. In that case, we simply sum all values # in the array and skip the background subtraction. sub64p_wlp8 = False if (datamodel.meta.instrument.pupil == 'WLP8' and datamodel.meta.subarray.name == 'SUB64P'): sub64p_wlp8 = True if not sub64p_wlp8: phot_aper = CircularAperture((xcenter, ycenter), r=radius) bkg_aper = CircularAnnulus((xcenter, ycenter), r_in=radius_inner, r_out=radius_outer) # convert the input data and errors from MJy/sr to Jy if datamodel.meta.bunit_data != 'MJy/sr': raise ValueError('data is expected to be in units of MJy/sr') factor = 1.e6 * datamodel.meta.photometry.pixelarea_steradians datamodel.data *= factor datamodel.err *= factor datamodel.meta.bunit_data = 'Jy' datamodel.meta.bunit_err = 'Jy' aperture_sum = [] aperture_sum_err = [] annulus_sum = [] annulus_sum_err = [] nimg = datamodel.data.shape[0] if sub64p_wlp8: info = ('Photometry measured as the sum of all values in the ' 'subarray. No background subtraction was performed.') for i in np.arange(nimg): aperture_sum.append(np.sum(datamodel.data[i, :, :])) aperture_sum_err.append(np.sqrt(np.sum(datamodel.err[i, :, :]**2))) else: info = ('Photometry measured in a circular aperture of r={0} ' 'pixels. Background calculated as the mean in a ' 'circular annulus with r_inner={1} pixels and ' 'r_outer={2} pixels.'.format(radius, radius_inner, radius_outer)) for i in np.arange(nimg): aper_sum, aper_sum_err = phot_aper.do_photometry( datamodel.data[i, :, :], error=datamodel.err[i, :, :]) ann_sum, ann_sum_err = bkg_aper.do_photometry( datamodel.data[i, :, :], error=datamodel.err[i, :, :]) aperture_sum.append(aper_sum[0]) aperture_sum_err.append(aper_sum_err[0]) annulus_sum.append(ann_sum[0]) annulus_sum_err.append(ann_sum_err[0]) aperture_sum = np.array(aperture_sum) aperture_sum_err = np.array(aperture_sum_err) annulus_sum = np.array(annulus_sum) annulus_sum_err = np.array(annulus_sum_err) # construct metadata for output table meta = OrderedDict() meta['instrument'] = datamodel.meta.instrument.name meta['detector'] = datamodel.meta.instrument.detector meta['channel'] = datamodel.meta.instrument.channel meta['subarray'] = datamodel.meta.subarray.name meta['filter'] = datamodel.meta.instrument.filter meta['pupil'] = datamodel.meta.instrument.pupil meta['target_name'] = datamodel.meta.target.catalog_name meta['xcenter'] = xcenter meta['ycenter'] = ycenter ra_icrs, dec_icrs = datamodel.meta.wcs(xcenter, ycenter) meta['ra_icrs'] = ra_icrs meta['dec_icrs'] = dec_icrs meta['apertures'] = info # initialize the output table tbl = QTable(meta=meta) # check for the INT_TIMES table extension if hasattr(datamodel, 'int_times') and datamodel.int_times is not None: nrows = len(datamodel.int_times) else: nrows = 0 log.warning("The INT_TIMES table in the input file is missing or " "empty.") # load the INT_TIMES table data if nrows > 0: shape = datamodel.data.shape if len(shape) == 2: num_integ = 1 else: # len(shape) == 3 num_integ = shape[0] int_start = datamodel.meta.exposure.integration_start if int_start is None: int_start = 1 log.warning(f"INTSTART not found; assuming a value of {int_start}") # Columns of integration numbers & times of integration from the # INT_TIMES table. int_num = datamodel.int_times['integration_number'] mid_utc = datamodel.int_times['int_mid_MJD_UTC'] offset = int_start - int_num[0] # both are one-indexed if offset < 0: log.warning("Range of integration numbers in science data extends " "outside the range in INT_TIMES table.") log.warning("Can't use INT_TIMES table.") del int_num, mid_utc nrows = 0 # flag as bad else: log.debug("Times are from the INT_TIMES table") time_arr = mid_utc[offset:offset + num_integ] int_times = Time(time_arr, format='mjd', scale='utc') # compute integration time stamps on the fly if nrows == 0: log.debug("Times computed from EXPSTART and EFFINTTM") dt = datamodel.meta.exposure.integration_time n_dt = (datamodel.meta.exposure.integration_end - datamodel.meta.exposure.integration_start + 1) dt_arr = (np.arange(1, 1 + n_dt) * dt - (dt / 2.)) int_dt = TimeDelta(dt_arr, format='sec') int_times = (Time(datamodel.meta.exposure.start_time, format='mjd') + int_dt) # populate table columns unit = u.Unit(datamodel.meta.bunit_data) tbl['MJD'] = int_times.mjd tbl['aperture_sum'] = aperture_sum << unit tbl['aperture_sum_err'] = aperture_sum_err << unit if not sub64p_wlp8: tbl['annulus_sum'] = annulus_sum << unit tbl['annulus_sum_err'] = annulus_sum_err << unit annulus_mean = annulus_sum / bkg_aper.area annulus_mean_err = annulus_sum_err / bkg_aper.area aperture_bkg = annulus_mean * phot_aper.area aperture_bkg_err = annulus_mean_err * phot_aper.area tbl['annulus_mean'] = annulus_mean << unit tbl['annulus_mean_err'] = annulus_mean_err << unit tbl['aperture_bkg'] = aperture_bkg << unit tbl['aperture_bkg_err'] = aperture_bkg_err << unit net_aperture_sum = aperture_sum - aperture_bkg net_aperture_sum_err = np.sqrt(aperture_sum_err**2 + aperture_bkg_err**2) tbl['net_aperture_sum'] = net_aperture_sum << unit tbl['net_aperture_sum_err'] = net_aperture_sum_err << unit else: colnames = [ 'annulus_sum', 'annulus_sum_err', 'annulus_mean', 'annulus_mean_err', 'aperture_bkg', 'aperture_bkg_err' ] for col in colnames: tbl[col] = np.full(nimg, np.nan) tbl['net_aperture_sum'] = aperture_sum << unit tbl['net_aperture_sum_err'] = aperture_sum_err << unit return tbl
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)
class RadialProfile: """Main function to calulate radial profiles Computes a radial profile of a source in an array. This function leverages some of the tools in photutils to cutout the small region around the source. This function can first recenter the source via a 2d Gaussian fit (radial profiles are sensitive to centroids) and then fit a 1D Moffat profile to the values. The profile is calculated by computing the distance from the center of each pixel within a box of size r to the centroid of the source in the box. Additionally, the profile and the fit can be plotted. If fit is set to True, then the profile is fit with a 1D Moffat. If show is set to True, then profile (and/or fit) is plotted. If an axes object is provided, the plot(s) will be on that object. NOTE: THE POSITIONS ARE 0 INDEXED (bottom left corner pixel center is set to (0,0)). Parameters ---------- x : float The x position of the centroid of the source. ZERO INDEXED. stored in the .x attribute y : float The y position of the centroid of the source. ZERO INDEXED. .x attribute data : array A 2D array containing the full image data. A small box is cut out of this array for the radial profile r : float, optional The size of the box used to cut out the source pixels. The box is typically square with side length ~ 2*r + 1. Default is 5 pix. fit: bool Fit a 1D Moffat profile? Default True. Required for computation of FWHM. recenter : bool, optional Compute new centroid via 2D Gaussian fit? Default False. show : bool, optional Plot the profile? Default False. See ax parameter for info. ax : matplotlib.axes.Axes, optional Axes object to make the plots on. Default None. If None and show is True, an axes object will be created. Attributes ---------- x : float The x position in pixels of the source centroid. Gets updated if the profile is recentered. y : float The y position in pixels of the source centroid. Gets updated if the profile is recentered. fwhm : float The FWHM of the fitted profile, only computed if fit=True old_x : float The x position in pixels of the original input centroid. Only set if recenter = True old_y : float The y position in pixels of the original input centroid. Only set if recenter = True fitted : bool Whether the data has had a profile fit. Only True if fit=True and fitting was successful is_empty : bool Whether cutout is empty or not. True if position falls entirely off of data. cutout : array 2D array containing small cutout of data around source distances : array Array containing distance to each pixel in cutout from centroid value : array Array containing all the values in the cutout """ def __init__(self, x, y, data, r=5, fit=True, recenter=False, show=False, ax=None): self.x = x # X position self.y = y # Y Position self.r = r # radius (acutally makes a box) self.is_empty = False # if gets set True, cutout is empty self._setup_cutout(data) # Make the cutout if recenter: self.recenter_source(data) # recalculates centroid self.fit = fit self.fitted = False # Initial state, set to true if fit success if self.is_empty: self.fwhm = np.nan else: self._create_profile() # creates distances and values arrays if fit: self.fit_profile() # performs fit, updates self.fitted if show: self.show_profile(ax) def _create_profile(self): """Compute distances to pixels in cutout""" iY, iX = np.mgrid[self.sy, self.sx] # Pixel grid indices # extent = [sx.start, sx.stop-1, sy.start, sy.stop-1] self.distances = np.sqrt((iX - self.x)**2. + (iY - self.y)**2.).flatten() self.values = self.cutout.flatten() def _setup_cutout(self, data): """Cuts out the aperture and defines slice objects. General setup procedure. """ self.ap = CircularAperture((self.x, self.y), r=self.r) mask = self.ap.to_mask()[0] self.sy = mask.bbox.slices[0] self.sx = mask.bbox.slices[1] self.cutout = mask.cutout(data, fill_value=np.nan) if self.cutout is None: self.is_empty = True def fit_profile(self): """Fits 1d Moffat function to measured radial profile. Fits a moffat profile to the distance and values of the pixels. Further development may allow user defined models. """ try: amp0 = np.amax(self.values) bias0 = np.nanmedian(self.values) best_vals, covar = curve_fit(RadialProfile.profile_model, self.distances, self.values, p0=[amp0, 1.5, 1.5, bias0], bounds=([0., .3, .5, 0], [np.inf, 10., 10., np.inf])) hwhm = best_vals[1] * np.sqrt(2.**(1. / best_vals[2]) - 1.) self.fwhm = 2 * hwhm self.amp, self.gamma, self.alpha, self.bias = best_vals self.fitted = True mod = RadialProfile.profile_model(self.distances, *best_vals) self.chisquared = chisquare(self.values, mod, ddof=4)[0] except Exception as e: print(e) self.amp, self.gamma, self.alpha, self.bias = [np.nan] * 4 self.fwhm = np.nan self.fitted = False self.chisquared = np.nan @staticmethod def profile_model(r, amp, gamma, alpha, bias): """Returns 1D Moffat profile evaluated at r values. This function takes radius values and parameters in a simple 1D moffat profiles and returns the values of the profile at those radius values. The model is defined as: model = amp * (1. + (r / gamma) ** 2.) ** (-1. * alpha) + bias Parameters ---------- r : array The distances at which to sample the model amp : float The amplitude of the of the model gamma: float The width of the profile. alpha: float The decay of the profile. bias: float The bias level (piston term) of the data. This is like a background value. Returns ------- model : array The values of the model sampled at the r values. """ model = amp * (1. + (r / gamma)**2.)**(-1. * alpha) + bias return model def recenter_source(self, data): """Recenters source position in cutout and updates x,y attributes""" # Archive old positions. self.old_x = self.x self.old_y = self.y if self.is_empty: self.x, self.y = np.nan, np.nan else: # Fit 2D gaussian xg1, yg1 = centroid_2dg(self.cutout) dx = xg1 + self.sx.start - self.x dy = yg1 + self.sy.start - self.y dr = (dx**2. + dy**2.)**.5 if dr > 2.: print('Large shift of {},{} computed.'.format(dx, dy)) print('Rejecting and keeping original x, y coordinates') else: self.x = xg1 + self.sx.start self.y = yg1 + self.sy.start self._setup_cutout(data) def show_profile(self, ax=None, show_fit=True): """Makes plot of radial profile Plots the radial profile, that is pixel distance vs pixel value. Can plot on an existing axes object if the an axes object is passed in via the ax parameter. The function attempts to set sensible axes limits, specifically half of the smallest positive value (axes are logarithmic). The axes object is returned by this, so that parameters can be set by the user later. Parameters ---------- ax : matplotlib.axes.Axes, optional An axes object to plot the radial profile on (for integrating) the plot into other figures. If not set, the script will create an axes object. show_fit : bool, optional Plot the fitted model. Only done if fit was successful. Returns ------- ax : matplotlib.axes.Axes The axes object containing the radial profile plot/ """ if ax is None: fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(self.distances, self.values, alpha=.5) min_y = np.amin(self.values[self.values > 0.]) / 2. ax.set_ylim(min_y, np.nanmax(self.values) * 2.) ax.set_xlim(0.) ax.set_yscale('log') ax.set_ylabel('Pixel Value') ax.set_xlabel('Distance from centroid [pix]') if self.fitted and show_fit: tmp_r = np.arange(0, np.ceil(np.amax(self.distances)), .1) model_fit = RadialProfile.profile_model(tmp_r, self.amp, self.gamma, self.alpha, self.bias) label = r'$\gamma$= {}, $\alpha$ = {}'.format( round(self.gamma, 2), round(self.alpha, 2)) label += '\nFWHM = {}'.format(round(self.fwhm, 2)) ax.plot(tmp_r, model_fit, label=label) ax.legend(loc=1) return ax
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 if __name__ == "__main__": print("###### Start to process the data ######") start_time = datetime.datetime.now() positions = [(126.05284, 249.11)] aperture = CircularAperture(positions, r=2) annulus = CircularAnnulus(positions, r_in=4, r_out=6) # ADI data #ADI_res, ADI_SN = get_photometry("./ADI") #ADI_res, ADI_SN = get_photometry("./ADI_WITH_MASK") #ADI_res_32, ADI_SN_32 = get_photometry("./ADI_WITH_MASK_32") #print(ADI_res_32) # RDI data 1 target 2 ref stars #RDI_res_2_ref, RDI_2_SN = get_photometry("./RDI_ref_2_star") #print(RDI_res_2_ref) # RDI data 1 target 4 ref stars #RDI_res_4_ref, RDI_4_SN = get_photometry("./RDI_ref_4_star") #print(RDI_res_4_ref)
def getCircularApetures(center,radius): positions = setCenters(center,radius) apetures = [CircularAperture(pos,r=radius) for pos in positions] return apetures
psfn = vip.metrics.normalize_psf(psf[wl_final], fwhm, size=17) print("psfn =", psfn.shape, "psfn.ndim =", psfn.ndim) 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))
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)