def CrowdedFieldSingle(AvgFlux,XPos,YPos, StdCutOff=3.0):
'''returns the best aperture from the crowded field'''
MedianFlux = np.median(AvgFlux)
Std = np.std(np.nonzero(AvgFlux*(AvgFlux<MedianFlux)))
Mask = AvgFlux>(MedianFlux+ StdCutOff*Std)
MaskValue = MedianFlux + StdCutOff*Std
MaskedImage = AvgFlux*Mask
sigma_psf = 2.0
#daofind = DAOStarFinder(fwhm=4., threshold=1.5*std)
iraffind = IRAFStarFinder(threshold=MaskValue, fwhm=4.0, minsep_fwhm=0.01, sharplo=-20.0, sharphi=20.0,roundhi=20.0, roundlo=-20.0)
#fwhm=sigma_psf*gaussian_sigma_to_fwhm)
sources = iraffind(MaskedImage)
StarUpdLocation = np.zeros((len(AvgFlux),len(AvgFlux[0])))
for i in range(len(sources)):
StarUpdLocation[int(round(sources['ycentroid'][i],0)), int(round(sources['xcentroid'][i],0))] = i+1
Apertures = watershed(-MaskedImage, StarUpdLocation, mask=Mask)
Distance= 6.0
for i in range(1,np.max(Apertures)):
TempAper = Apertures==i
TempImage = TempAper*MaskedImage
YCen, XCen = measurements.center_of_mass(TempImage)
TempDistance = ((XPos-XCen)**2+(YPos-YCen)**2)**0.5
if TempDistance<Distance:
Distance=TempDistance
StdAper = TempAper
if Distance>5.5:
print "Failed to find a good aperture"
StdAper = Apertures==np.max(Apertures)
return StdAper
def CrowdedFieldMultiple(AvgFlux, XPos, YPos, StdCutOff=3.0):
'''returns the best aperture from the crowded field'''
'''returns the best aperture from the crowded field'''
MedianFlux = np.median(AvgFlux)
Std = np.std(np.nonzero(AvgFlux * (AvgFlux < MedianFlux)))
Mask = AvgFlux > (MedianFlux + StdCutOff * Std)
MaskValue = MedianFlux + StdCutOff * Std
MaskedImage = AvgFlux * Mask
sigma_psf = 2.0
#daofind = DAOStarFinder(fwhm=4., threshold=1.5*std)
iraffind = IRAFStarFinder(threshold=MaskValue,
fwhm=4.0,
minsep_fwhm=0.01,
sharplo=-20.0,
sharphi=20.0,
roundhi=20.0,
roundlo=-20.0)
#fwhm=sigma_psf*gaussian_sigma_to_fwhm)
sources = iraffind(MaskedImage)
StarUpdLocation = np.zeros((len(AvgFlux), len(AvgFlux[0])))
for i in range(len(sources)):
StarUpdLocation[int(round(sources['ycentroid'][i], 0)),
int(round(sources['xcentroid'][i], 0))] = i + 1
Distance = np.exp(-1.05 * (distance_transform_edt(Mask))**2)
Apertures = watershed(-MaskedImage, StarUpdLocation, mask=Mask)
return Apertures
def PSF_photometry(data, coord_table, sigma_psf=10, scale=0.67, step=0.5):
FLUX = []
bkgrms = MADStdBackgroundRMS()
std = bkgrms(data)
iraffind = IRAFStarFinder(threshold=3.5 * std,
fwhm=sigma_psf * gaussian_sigma_to_fwhm,
minsep_fwhm=0.01,
roundhi=5.0,
roundlo=-5.0,
sharplo=0.0,
sharphi=2.0)
daogroup = DAOGroup(2.0 * sigma_psf * gaussian_sigma_to_fwhm)
mmm_bkg = MMMBackground()
fitter = LevMarLSQFitter()
psf_model = IntegratedGaussianPRF(sigma=sigma_psf)
# psf_model.x_0.fixed = True
# psf_model.y_0.fixed = True
pos = Table(names=['x_0', 'y_0'],
data=[coord_table['X'],
coord_table['Y']])[coord_table['good_star']]
photometry = IterativelySubtractedPSFPhotometry(finder=iraffind,
group_maker=daogroup,
bkg_estimator=mmm_bkg,
psf_model=psf_model,
fitter=LevMarLSQFitter(),
niters=1,
fitshape=(41, 41))
result_tab = photometry(image=data, init_guesses=pos)
return result_tab['flux_fit']
def first_run(image, fwhm, nsigma, debug=0, mask=None):
mean, median, std_dev = sigma_clipped_stats(image, mask=mask, sigma=nsigma)
# daofind = DAOStarFinder(fwhm=fwhm, threshold=5.*std_dev)
# sources = daofind(image - median)
threshold = nsigma * std_dev
print("first_run: mean, median, std_dev, threshold ", mean, median,
std_dev, threshold)
iraf_find = IRAFStarFinder(threshold, fwhm)
sources = iraf_find(image - median)
if (debug == 1):
print("mean, median, std_dev ", mean, median, std_dev)
print("detection threshold ", threshold)
for col in sources.colnames:
sources[col].info.format = "%.8g"
print(sources)
np.fwhm = sources['fwhm']
np.area = np.log10(sources['npix'])
np.flux = sources['flux']
np.mag = sources['mag']
np.roundness = sources['roundness']
np.sharpness = sources['sharpness']
fig, ax = plt.subplots()
plt.plot(np.area, np.mag, 'bo', markersize=1)
ax.set_xlabel('Log(area)')
ax.set_ylabel('mag')
plt.show()
plt.plot(np.roundness, np.sharpness, 'bo', markersize=1)
ax.set_xlabel('roundness')
ax.set_ylabel('sharpness')
plt.show()
return sources
def starfinder(image_name):
infos = image_info(image_name)
mean_bkg = infos.bkg
std_bkg = infos.std
u_sigma = infos.u_sigma
sigma = u_sigma.n
print 3.0 * std_bkg + mean_bkg
iraffind = IRAFStarFinder(threshold = 3.0*std_bkg + mean_bkg, \
# fwhm = sigma*gaussian_sigma_to_fwhm, \
fwhm = 5.0,
roundhi = 1.0,
roundlo = -1.0,
sharphi = 2.0,
sharplo = 0.5)
iraf_table = iraffind.find_stars(infos.data)
return iraf_table, infos
def irafdetect(image,nsigma=1.5,fwhm=3.0):
""" Detection with IRAFFinder."""
threshold = np.median(image.error)*nsigma
iraffind = IRAFStarFinder(fwhm=fwhm, threshold=threshold, sky=0.0)
objects = iraffind(image.data-image.sky, mask=image.mask)
# homogenize the columns
objects['xcentroid'].name = 'x'
objects['ycentroid'].name = 'y'
return objects
def astropy_psf_photometry(img,
sigma_psf,
aperture=3,
x0=None,
y0=None,
filter=True,
sigma_filter=1):
"""
performs PSF photometry on an image. If x0 and y0 are None will attempt to locate the target by searching for the
brightest PSF in the field
:param img: 2D array, image on which to perform PSF photometry
:param sigma_psf: float, standard deviation of the PSF
:param aperture: int, size of the paerture (pixels)
:param x0: x position of the target (pixels)
:param y0: y position of the target (pixels)
:param filter: If True will apply a gaussian filter to the image with standard deviation sigma_filter before
performing PSF photometry
:param sigma_filter: standard deviation of gaussian filter to apply to the image
:return: x0 column of photometry table, y0 column of photometry table, flux column of photometry table
"""
if filter:
image = ndimage.gaussian_filter(img, sigma=sigma_filter, order=0)
else:
image = img
bkgrms = MADStdBackgroundRMS()
std = bkgrms(image[image != 0])
iraffind = IRAFStarFinder(threshold=2 * std,
fwhm=sigma_psf * gaussian_sigma_to_fwhm,
minsep_fwhm=0.01,
roundhi=5.0,
roundlo=-5.0,
sharplo=0.0,
sharphi=2.0)
daogroup = DAOGroup(2.0 * sigma_psf * gaussian_sigma_to_fwhm)
mmm_bkg = MMMBackground()
fitter = LevMarLSQFitter()
psf_model = IntegratedGaussianPRF(sigma=sigma_psf)
if x0 and y0:
pos = Table(names=['x_0', 'y_0'], data=[x0, y0])
photometry = BasicPSFPhotometry(group_maker=daogroup,
bkg_estimator=mmm_bkg,
psf_model=psf_model,
fitter=LevMarLSQFitter(),
fitshape=(11, 11))
res = photometry(image=image, init_guesses=pos)
return res['x_fit'], res['y_fit'], res['flux_0']
photometry = BasicPSFPhotometry(finder=iraffind,
group_maker=daogroup,
bkg_estimator=mmm_bkg,
psf_model=psf_model,
fitter=fitter,
fitshape=(11, 11),
aperture_radius=aperture)
res = photometry(image=image)
return res['x_0'], res['y_0'], res['flux_0']
def get_star_catalog(img_file, fwhm_init=5.0, threshold=3.5):
img_hdu = fits.open(img_file)
std = bkgrms(img_hdu[0].data)
iraffind = IRAFStarFinder(threshold=threshold*std,
fwhm=fwhm_init, minsep_fwhm=0.5,
roundhi=2.0, roundlo=-2.0,sharplo=0.0, sharphi=2.0)
# Get initial set of stars in image with iraffind
print('Finding stars...')
stars = iraffind(img_hdu[0].data)
return(stars)
def do_photometry_basic(image: np.ndarray,
σ_psf: float) -> Tuple[Table, np.ndarray]:
"""
Find stars in an image with IRAFStarFinder
:param image: The image data you want to find stars in
:param σ_psf: expected deviation of PSF
:return: tuple result table, residual image
"""
bkgrms = MADStdBackgroundRMS()
std = bkgrms(image)
iraffind = IRAFStarFinder(threshold=3 * std,
sigma_radius=σ_psf,
fwhm=σ_psf * gaussian_sigma_to_fwhm,
minsep_fwhm=2,
roundhi=5.0,
roundlo=-5.0,
sharplo=0.0,
sharphi=2.0)
daogroup = DAOGroup(0.1 * σ_psf * gaussian_sigma_to_fwhm)
mmm_bkg = MMMBackground()
# my_psf = AiryDisk2D(x_0=0., y_0=0.,radius=airy_minimum)
# psf_model = prepare_psf_model(my_psf, xname='x_0', yname='y_0', fluxname='amplitude',renormalize_psf=False)
psf_model = IntegratedGaussianPRF(sigma=σ_psf)
# psf_model = AiryDisk2D(radius = airy_minimum)#prepare_psf_model(AiryDisk2D,xname ="x_0",yname="y_0")
# psf_model = Moffat2D([amplitude, x_0, y_0, gamma, alpha])
# photometry = IterativelySubtractedPSFPhotometry(finder=iraffind, group_maker=daogroup,
# bkg_estimator=mmm_bkg, psf_model=psf_model,
# fitter=LevMarLSQFitter(),
# niters=2, fitshape=(11,11))
photometry = BasicPSFPhotometry(finder=iraffind,
group_maker=daogroup,
bkg_estimator=mmm_bkg,
psf_model=psf_model,
fitter=LevMarLSQFitter(),
aperture_radius=11.0,
fitshape=(11, 11))
result_table = photometry.do_photometry(image)
return result_table, photometry.get_residual_image()
def find_objects(image, fwhm, nsigma, debug, mask=None):
mean, median, std_dev = sigma_clipped_stats(image, mask=mask, sigma=nsigma)
threshold = nsigma * std_dev
if (debug == 1):
print("mean, median, std_dev ", mean, median, std_dev)
print("nsigma, detection threshold ", nsigma, threshold)
iraf_find = IRAFStarFinder(threshold,
fwhm,
minsep_fwhm=25.0,
sharplo=0.5,
sharphi=2.0,
roundlo=0.0,
roundhi=0.05,
peakmax=1000,
exclude_border=True,
brightest=100)
sources = iraf_find(image - median, mask=mask)
return sources
def init_setup():
fitimage = fits.open('Serpens3/idxq28010_drz.fits')
imdata = fitimage[1].data
head = fitimage[0].header
bkgrms = MADStdBackgroundRMS()
std = bkgrms(imdata)
mean = np.mean(imdata)
sigma_psf = 2.0
iraffind = IRAFStarFinder(threshold=3.5 * std,
fwhm=sigma_psf * gaussian_sigma_to_fwhm,
minsep_fwhm=0.01,
roundhi=5.0,
roundlo=-5.0,
sharplo=0.0,
sharphi=2.0)
daogroup = DAOGroup(2.0 * sigma_psf * gaussian_sigma_to_fwhm)
mmm_bkg = MMMBackground()
return imdata, bkgrms, std, sigma_psf, iraffind, daogroup, mmm_bkg, mean
# Largeur à mi-hauteur totale d'une étoile
fwhm = 12
# On commence par faire de la photométrie de base sur le fichier somme BV.
# Les données calculées pour le fichier somme serviront de point de départ à l'algorithme
# pour les images en filtre B et V.
################################## SUM BV ################################
# On commence par déterminer la déviation standard du fond de ciel.
bkgrms = MADStdBackgroundRMS ()
std = bkgrms (imageSumBV)
# On donne les paramètres du finder pour déterminer les étoiles de base dans l'image
iraffind = IRAFStarFinder (threshold = 10 * std,
fwhm = fwhm,
minsep_fwhm = 0.01, roundhi = 1.0, roundlo = -1.0,
sharplo = 0.1, sharphi = 0.8)
# On donne un critère de groupage des étoiles
daogroup = DAOGroup (2.0 * fwhm)
# On détermine le fond de ciel et la procédure de fitting
mmm_bkg = MMMBackground ()
fitter = LevMarLSQFitter ()
psf_model = IntegratedGaussianPRF (sigma = fwhm / 2.35)
# On met tout ça dans une boîte noire qui fait des itérations soustractives
photometry = IterativelySubtractedPSFPhotometry (finder = iraffind,
group_maker = daogroup,
def foo():
config = Config()
config.epsfbuilder_iters = 2
config.clip_sigma = 2.
config.threshold_factor = 1.
config.separation_factor = 2.
image, input_table = read_or_generate_image('scopesim_cluster', config)
mean, median, std = sigma_clipped_stats(image, sigma=config.clip_sigma)
threshold = median + config.threshold_factor * std
finder = IRAFStarFinder(threshold=threshold,
fwhm=config.fwhm_guess,
minsep_fwhm=1)
prelim_stars = make_stars_guess(image, finder)
prelim_epsf = make_epsf_combine(prelim_stars)
fwhm_guess = estimate_fwhm(prelim_epsf)
finder = IRAFStarFinder(threshold=threshold,
fwhm=fwhm_guess,
minsep_fwhm=1)
# peaks_tbl = IRAFStarFinder(threshold, fwhm_guess, minsep_fwhm=1)(image)
# peaks_tbl = finder(image)
# peaks_tbl.rename_columns(['xcentroid', 'ycentroid'], ['x_fit', 'y_fit'])
# plot_image_with_source_and_measured(image, input_table, peaks_tbl)
stars = make_stars_guess(image, cutout_size=51, star_finder=finder)
epsf = make_epsf_fit(stars,
iters=config.epsfbuilder_iters,
smoothing_kernel=make_gauss_kernel())
epsf_mod = photutils.psf.prepare_psf_model(epsf, renormalize_psf=False)
grouper = DAOGroup(config.separation_factor * fwhm_guess)
shape = (epsf_mod.psfmodel.shape / epsf_mod.psfmodel.oversampling).astype(
np.int64)
epsf_mod.fwhm = astropy.modeling.Parameter(
'fwhm', 'this is not the way to add this I think')
epsf_mod.fwhm.value = fwhm_guess
finder = IRAFStarFinder(threshold=0.1 * threshold,
fwhm=fwhm_guess,
minsep_fwhm=0.1)
init_guesses = finder(image)
init_guesses.rename_columns(('xcentroid', 'ycentroid'), ('x_0', 'y_0'))
photometry = BasicPSFPhotometry(
finder=finder,
group_maker=grouper,
bkg_estimator=MADStdBackgroundRMS(),
psf_model=epsf_mod,
fitter=LevMarLSQFitter(),
fitshape=shape,
)
res = photometry(image, init_guesses=init_guesses)
init_guesses.rename_columns(('x_0', 'y_0'), ('x', 'y'))
plot_xy_deviation(init_guesses, res)
def SubmitEvent(self):
#Not a fan of globals but this is the easiest way to grab the file location
global fileLocation
#sigma_psf = 2.88
#Grab the Sigma from the Entry box in the GUI
SigmaPSF = SigmaPSFentry.get()
#Turn the string into a float
sigma_psf = float(SigmaPSF)
#Grab the number of iterations from Entry box in GUI
N_iters1 = nitersEntry.get()
#Turn the string into a float
N_iters = float(N_iters1)
#Test cases to make sure that information was flowing from the GUI to the program
#print(SigmaPSF)
#print(N_iters)
#Open the file as a fits (allows us to handle it) then turn that into readable data.
with fits.open(fileLocation) as hdul:
image = hdul[0].data
#automatically gathered information needed to run the Star Finder
bkgrms = MADStdBackgroundRMS()
std = bkgrms(image)
#Find the stars
iraffind = IRAFStarFinder(threshold=3.5 * std,
fwhm=sigma_psf * gaussian_sigma_to_fwhm,
minsep_fwhm=0.01,
roundhi=5.0,
roundlo=-5.0,
sharplo=0.0,
sharphi=2.0)
#Group the stars
daogroup = DAOGroup(2.0 * sigma_psf * gaussian_sigma_to_fwhm)
#More automatically gathered info needed for IS-PSFPhotometry to take places
mmm_bkg = MMMBackground()
fitter = LevMarLSQFitter()
#Grabbed from the user input
psf_model = IntegratedGaussianPRF(sigma=sigma_psf)
#Run IS-PSFPhotometry
photometry = IterativelySubtractedPSFPhotometry(
finder=iraffind,
group_maker=daogroup,
bkg_estimator=mmm_bkg,
psf_model=psf_model,
fitter=LevMarLSQFitter(),
niters=N_iters,
fitshape=(11, 11))
#Do photometry on the image
result_tab = photometry(image=image)
#grab the resiudal image
residual_image = photometry.get_residual_image()
#Get the results of the photometry and print the aspects we want.
phot_results = photometry(image)
with open("output.txt", "w") as text_file:
print(phot_results['x_fit', 'y_fit', 'flux_fit'],
file=text_file)
print(phot_results['x_fit', 'y_fit', 'flux_fit'])
print("Sum of pixels: {}".format(sum(sum(residual_image))))
#Plot images made#
#Start by creating plots.
plt.subplot(1, 5, 1)
#Show the first plot (which is just the raw image)
plt.imshow(image,
cmap='viridis',
aspect=1,
interpolation='nearest',
origin='lower')
plt.title('Raw')
plt.colorbar(orientation='horizontal', fraction=0.046, pad=0.04)
#Create the second plot
plt.subplot(1, 5, 2)
#Show the residual_image
plt.imshow(residual_image,
cmap='viridis',
aspect=1,
interpolation='nearest',
origin='lower')
plt.title('PSF')
plt.colorbar(orientation='horizontal', fraction=0.046, pad=0.04)
#Draw in the sum of pixels.
plt.text(0,
65,
"Sum of pixels: {}".format(sum(sum(residual_image))),
fontsize=7)
#Create the third plot which is the subtracted images combined.
sb = image - residual_image
plt.subplot(1, 5, 3)
plt.imshow(sb,
cmap='viridis',
aspect=1,
interpolation='nearest',
origin='lower')
plt.title('PSF-S')
plt.colorbar(orientation='horizontal', fraction=0.046, pad=0.04)
with open("AP_RI.txt", "w") as f:
for _ in range(len(residual_image)):
f.write(str(residual_image[_]))
with open("AP_BS.txt", "w") as f:
for _ in range(len(sb)):
f.write(str(sb[_]))
print("Starting creation of CSV")
subprocess.run(['py', 'create_CSV.py'], shell=False)
print("Starting creation of Stats")
subprocess.run(['py', 'create_info.py'], shell=False)
print("Starting Threshold")
subprocess.run(['py', 'threshold.py'], shell=False)
with open("APC_Res.csv", "r") as f:
APC_Res = f.read()
APC_Res = APC_Res.split(",")
APC_Res = [float(i) for i in APC_Res]
#Every (SquareRoot of the Pixels) datapoints create a new array. Into a 2D Array.
#I'm going to use the Correct_Res list as the main list and store the temp list every Sqrt(pix) in it,
#then reset that list and continue until the pixel count is met.
#Have an internal counter. Reset that every Sqrt(Pix)
temp_list = np.array([])
SqrPixels = math.sqrt(len(APC_Res))
internal_counter = 0
#print(SqrPixels)
#print(len(APC_Res))
Corrected_Res = np.array([[]])
for _ in range(len(APC_Res)):
if internal_counter <= SqrPixels - 2:
try:
temp_list = np.append(temp_list, APC_Res[_ - 1])
#print(_)
if _ + 1 == (int(SqrPixels) * int(SqrPixels)):
Corrected_Res = np.append(Corrected_Res, temp_list)
except:
print("Not right 2.0")
internal_counter = internal_counter + 1
else:
internal_counter = 0
#print(temp_list)
Corrected_Res = np.append(Corrected_Res, temp_list)
temp_list = []
temp_list = np.append(temp_list, APC_Res[_ - 1])
#print("Resetting Counter & List {}".format(_))
if _ + 1 == (int(SqrPixels) * int(SqrPixels)):
Corrected_Res = np.append(Corrected_Res, temp_list)
#print(_+1)
#print("Iteration {}".format(_))
#print(residual_image)
#print("\n")
#print(Corrected_Res)
Corrected_Res = np.reshape(Corrected_Res,
(int(SqrPixels), int(SqrPixels)))
Correct_BS = image - Corrected_Res
plt.subplot(1, 5, 4)
plt.imshow(Corrected_Res,
cmap='viridis',
aspect=1,
interpolation='nearest',
origin='lower')
plt.title('CPSF')
plt.colorbar(orientation='horizontal', fraction=0.046, pad=0.04)
plt.subplot(1, 5, 5)
plt.imshow(Correct_BS,
cmap='viridis',
aspect=1,
interpolation='nearest',
origin='lower')
plt.title('CPSF-S')
plt.colorbar(orientation='horizontal', fraction=0.046, pad=0.04)
#Number of bins
n_bins = 20
#Not super sure why this works the way that it does if I’m being truthful, took tinkering to work, and lots of documentation examples.
fig, axs = plt.subplots(1, 2)
# We can set the number of bins with the `bins` kwarg
axs[0].hist(residual_image, bins=n_bins)
plt.title('Residual Image Hist')
axs[1].hist(sb, bins=n_bins)
plt.title('Background Subtracted Hist')
#plt.colorbar(orientation='horizontal', fraction=0.046, pad=0.04)
#All Pixels from residual image
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
delta = (6 * (1 / len(sb)))
nx = ny = np.arange(-3.0, 3.0, delta)
X, Y = np.meshgrid(nx, ny)
#print(X)
#print(Y)
x, y, z = X * len(sb), Y * len(sb), sb
ax.plot_surface(x, y, z, rstride=1, cstride=1, cmap='viridis')
figi = plt.figure()
axi = figi.add_subplot(111, projection='3d')
deltai = (6 * (1 / len(sb)))
nxi = nyi = np.arange(-3.0, 3.0, deltai)
Xi, Yi = np.meshgrid(nxi, nyi)
#print(X)
#print(Y)
xi, yi, zi = Xi * len(Correct_BS), Yi * len(Correct_BS), Correct_BS
axi.plot_surface(xi, yi, zi, rstride=1, cstride=1, cmap='viridis')
plt.show()
#plt.colorbar(orientation='horizontal', fraction=0.046, pad=0.04) #plt.show() #calculate background bkgrms = MADStdBackgroundRMS() std = bkgrms(image) print 'Background level :', std #find stars print 'Finding stars' iraffind = IRAFStarFinder(threshold=3.5*std, fwhm=fwhm, minsep_fwhm=0.01, roundhi=5.0, roundlo=-5.0, sharplo=0.0, sharphi=2.0) daogroup = DAOGroup(2.0*fwhm) mmm_bkg = MMMBackground() fitter = LevMarLSQFitter() psf_model = IntegratedGaussianPRF(sigma=(fwhm/gaussian_sigma_to_fwhm)) #fitshape must be odd fitshape = 2*int(fwhm)+1 print 'Performing photometry' #photometry = IterativelySubtractedPSFPhotometry(finder=iraffind, group_maker=daogroup, bkg_estimator=mmm_bkg, psf_model=psf_model,fitter=LevMarLSQFitter(), niters=None, fitshape=(fitshape, fitshape), aperture_radius=fwhm) #niters = None means continue until all stars subtracted - might recur infinitely
def Flux(self,x,y):
x = int(x)
y = int(y)
r = 25
data = self.hdulist[self.fz].data[x-r:x+r,y-r:y+r]
data = (lacosmic.lacosmic(data,2,10,10, effective_gain = self.gain, readnoise = self.readnoise))[0]
bkgrms = MADStdBackgroundRMS()
std = bkgrms(data)
iraffind = IRAFStarFinder(threshold=self.limit*std,
fwhm=self.sigma_psf*gaussian_sigma_to_fwhm,
minsep_fwhm=0.01, roundhi=5.0, roundlo=-5.0,
sharplo=0.0, sharphi=2.0)
daogroup = DAOGroup(2.0*self.sigma_psf*gaussian_sigma_to_fwhm)
mmm_bkg = MMMBackground()
psf_model = IntegratedGaussianPRF(sigma=self.sigma_psf)
from photutils.psf import IterativelySubtractedPSFPhotometry
photometry = IterativelySubtractedPSFPhotometry(finder=iraffind,
group_maker=daogroup,
bkg_estimator=mmm_bkg,
psf_model=psf_model,
fitter=LevMarLSQFitter(),
niters=1, fitshape=(21,21))
result_tab = photometry(image=data)
"""
if plot == 1:
residual_image = photometry.get_residual_image()
print(result_tab['x_fit','y_fit'])
plt.figure(self.filename+' data')
plt.imshow(data, cmap='viridis',
aspect=1, interpolation='nearest', origin='lower')
plt.show()
plt.figure(self.filename+' residual')
plt.imshow(residual_image, cmap='viridis',
aspect=1, interpolation='nearest', origin='lower')
plt.show()
plt.figure(self.filename+' PSF')
plt.imshow(data-residual_image, cmap='viridis',
aspect=1, interpolation='nearest', origin='lower')
plt.show()
"""
if len(result_tab) > 5:
return(0,0)
if len(result_tab) ==0:
print('None')
return(0,0)
result_tab['Minus'] = np.zeros(len(result_tab))
for i in range(len(result_tab)):
if 18.5 < result_tab['x_fit'][i] < 28.5 and 18.5 < result_tab['y_fit'][i] < 28.5:
#if 15 < result_tab['x_fit'][i] < 25 and 15 < result_tab['y_fit'][i] < 25:
result_tab['Minus'][i] = 1
else:
result_tab['Minus'][i] = 0
mask = result_tab['Minus'] == 1.0
result_tab = result_tab[mask]
if len(result_tab) != 1:
return(0,0)
flux_counts = float(result_tab['flux_fit'][0])
flux_unc = float(result_tab['flux_unc'][0])
flux_unc = flux_unc/flux_counts
return(flux_counts,flux_unc)
##THIS IS THE SIGMA, CHANGE THIS FOR RESULTS
sigma_psf = 3.1
##THIS IS THE FILE, CHANGE THIS FOR RESULTS
with fits.open(
r'/Users/phystastical/Desktop/BB2/script/twomass-j.fits') as hdul:
image = hdul[0].data
bkgrms = MADStdBackgroundRMS()
std = bkgrms(image)
iraffind = IRAFStarFinder(threshold=3.5 * std,
fwhm=sigma_psf * gaussian_sigma_to_fwhm,
minsep_fwhm=0.01,
roundhi=5.0,
roundlo=-5.0,
sharplo=0.0,
sharphi=2.0)
daogroup = DAOGroup(2.0 * sigma_psf * gaussian_sigma_to_fwhm)
mmm_bkg = MMMBackground()
fitter = LevMarLSQFitter()
psf_model = IntegratedGaussianPRF(sigma=sigma_psf)
photometry = IterativelySubtractedPSFPhotometry(finder=iraffind,
group_maker=daogroup,
bkg_estimator=mmm_bkg,
psf_model=psf_model,
fitter=LevMarLSQFitter(),
niters=1,
fitshape=(11, 11))
from astropy.nddata import NDData
from photutils import EPSFBuilder, prepare_psf_model, Background2D
from astropy.stats import SigmaClip
from photutils.background import MADStdBackgroundRMS, MMMBackground
import pickle
import os
image = fits.getdata('./cutout_BS90_V.fits').astype(np.float64)
epsf_file = 'epsf.pkl'
if not os.path.exists(epsf_file):
mean, median, std = sigma_clipped_stats(image)
threshold = median + 10 * std
finder = IRAFStarFinder(threshold=threshold, fwhm=4, minsep_fwhm=5, peakmax=image.max() / 0.8)
star_table = finder(image)
star_table.rename_columns(('xcentroid', 'ycentroid'),('x','y'))
sigma_clip = SigmaClip(sigma=5.0)
bkg_estimator = MMMBackground()
bkg = Background2D(image, 5, filter_size=(3, 3),
sigma_clip=sigma_clip, bkg_estimator=bkg_estimator)
nddata = NDData(image-bkg.background)
stars = extract_stars(nddata, star_table, size=51)
epsf, fitted_stars = EPSFBuilder(oversampling=4, maxiters=3, progress_bar=True, smoothing_kernel='quadratic')(stars)
epsf_model = prepare_psf_model(epsf, renormalize_psf=False)