def phot_sources(img, ota, fwhm):
"""
Run IRAF phot on the the sources found.
"""
iraf.ptools(_doprint=0)
# values determined by ralf/daniel @ wiyn
kg = 0.20
kr = 0.12
ki = 0.058
image = odi.reprojpath+'reproj_'+ota+'.'+str(img[16:])
coords = odi.sourcepath+'source_'+ota+'.'+str(img[16:-5])+'.xy'
output = odi.sourcepath+img[0:-5]+'.'+ota+'.phot.1'
phot_tbl = odi.sourcepath+img[0:-5]+'.'+ota+'.sourcephot'
# alas, we must use IRAF apphot to do the measuring
# first set common parameters (these shouldn't change if you're using ODI)
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread',"rdnoise")
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
iraf.datapars.setParam('airmass','airmass')
iraf.datapars.setParam('fwhmpsf',fwhm)
iraf.photpars.setParam('apertures',5.*fwhm) # use a big aperture for this
iraf.fitskypars.setParam('annulus',6.*fwhm)
if not os.path.isfile(output):
iraf.apphot.phot(image=image, coords=coords, output=output)
with open(phot_tbl,'w+') as txdump_out :
iraf.ptools.txdump(textfiles=output, fields="id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,peak,flux,image", expr='yes', headers='no', Stdout=txdump_out)
outputfile_clean = open(phot_tbl.replace('.sourcephot','_clean.sourcephot'),"w")
for line in open(phot_tbl,"r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF','999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.sourcephot','_clean.sourcephot'),phot_tbl)
return phot_tbl
def doPhot():
print 'Running doPhot'
try:
mapFile = open('map.dat')
except:
print 'map.dat not found. Exiting.'
sys.exit()
try:
changeFile = open('change.dat')
except:
print 'change.dat not found. Exiting.'
sys.exit()
coordList = list()
for line in mapFile:
coords = map(float,line.split())
coordList.append(coords)
coordList = np.array(coordList)
iraf.noao()
iraf.digiphot()
iraf.daophot()
iraf.ptools()
iraf.set(clobber='yes')
photFile = open('phot.dat', 'w')
for line in changeFile.readlines():
elms = line.split()
imageName = elms[0]
changeCoords = np.array([float(elms[1]),float(elms[2])])
newCoords = coordList + changeCoords
print 'Image: '+imageName
coordFile = makeCoordFile(newCoords)
iraf.noao.digiphot.daophot.phot(image=imagesDir+imageName, coords=coordFile, output='.temp-phot', skyfile='', verify='no', fwhmpsf=fwhmpsf, sigma=sigma, readnoise=readnoise, epadu=epadu, exposure=exposureHeader, obstime=obstimeHeader, calgorithm=calgorithm, cbox=cbox, apertures=apertures, annulus=annulus, dannulus=dannulus)
result = iraf.noao.digiphot.ptools.txdump(Stdout=1, textfiles='.temp-phot', fields='mag, merr, otime', expr='yes')
writeString = result[0].split()[-1] +' '+ ' '.join([' '.join(x.split()[:2]) for x in result])
photFile.write(writeString+"\n")
photFile.close()
raw_input('doPhot Done. Hit return key to continue.')
def phot_sources_full(img,fwhm,airmass,apfactor):
iraf.ptools(_doprint=0)
coords = img[:-5]+'_sources.coo'
output = img[:-5]+'.phot.1'
phot_tbl = img[:-5]+'.srcphot'
if not os.path.isfile(phot_tbl) :
print 'phot-ing ', img, ' from daofind'
iraf.unlearn(iraf.apphot.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread','rdnoise')
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('xairmass',airmass)
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
iraf.datapars.setParam('fwhmpsf',fwhm)
iraf.photpars.setParam('apertures',apfactor*fwhm)
iraf.fitskypars.setParam('annulus',6.5*fwhm)
iraf.apphot.phot(image=img, coords=coords, output=output)
with open(phot_tbl,'w+') as txdump_out:
iraf.ptools.txdump(textfiles=output, fields="id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,image",expr='yes', headers='no', Stdout=txdump_out)
outputfile_clean = open(phot_tbl.replace('.srcphot','_clean.srcphot'),"w")
for line in open(phot_tbl,"r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF','999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.srcphot','_clean.srcphot'),phot_tbl)
12.139, 1.000, 0.537, 0.477, 1.014, 0.011, 0.012, 0.023, 0.013,
0.012, 0.018
],
[
11.267, 1.076, 0.571, 0.508, 1.079, 0.011, 0.012, 0.028, 0.011,
0.013, 0.017
]]
# ------------------------------------------------------------------------------------------------------------------- #
# ------------------------------------------------------------------------------------------------------------------- #
# Load Required IRAF Packages
# ------------------------------------------------------------------------------------------------------------------- #
iraf.noao(_doprint=0)
iraf.digiphot(_doprint=0)
iraf.ptools(_doprint=0)
# ------------------------------------------------------------------------------------------------------------------- #
# ------------------------------------------------------------------------------------------------------------------- #
# Functions For Handling Files & Lists
# ------------------------------------------------------------------------------------------------------------------- #
def remove_file(file_name):
"""
Removes the file 'file_name' in the constituent directory.
Args:
file_name : Name of the file to be removed from the current directory
Returns:
None
"""
def escut(image, pos_file, fwhm, peak):
# input image file name, file name with matched source positions, **np.array of fwhm measurements for each source
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from pyraf import iraf
# import sewpy
import os
from matplotlib.path import Path
iraf.images(_doprint=0)
iraf.tv(_doprint=0)
iraf.ptools(_doprint=0)
iraf.noao(_doprint=0)
iraf.digiphot(_doprint=0)
iraf.photcal(_doprint=0)
iraf.apphot(_doprint=0)
iraf.imutil(_doprint=0)
iraf.unlearn(iraf.phot, iraf.datapars, iraf.photpars, iraf.centerpars,
iraf.fitskypars)
iraf.apphot.phot.setParam('interactive', "no")
iraf.apphot.phot.setParam('verify', "no")
iraf.datapars.setParam('datamax', 50000.)
iraf.datapars.setParam('gain', "gain")
iraf.datapars.setParam('ccdread', "rdnoise")
iraf.datapars.setParam('exposure', "exptime")
iraf.datapars.setParam('airmass', "airmass")
iraf.datapars.setParam('filter', "filter")
iraf.datapars.setParam('obstime', "time-obs")
# iraf.datapars.setParam('obstime',"date-obs")
iraf.datapars.setParam('sigma', "INDEF")
iraf.photpars.setParam('zmag', 0.)
iraf.centerpars.setParam('cbox', 9.)
iraf.centerpars.setParam('maxshift', 3.)
iraf.fitskypars.setParam('salgorithm', "median")
iraf.fitskypars.setParam('dannulus', 10.)
# clean up the indefs so we can actually do stats, but reassign them to 99999 so we don't lose track of things
# keep a separate list without them to do the median (we need floats)
indefs = np.where(fwhm == 'INDEF')
good = np.where(fwhm != 'INDEF')
fwhm[indefs] = 99.999
fwhm = fwhm.astype(float)
fwhm_good = fwhm[good].astype(float)
indefs = np.where(peak == 'INDEF')
peak[indefs] = -999.999
peak = peak.astype(float)
peak_good = peak[good].astype(float)
if not os.path.isfile(image[0:-5] + '.txdump'):
# findavgfwhm = sewpy.SEW(
# params = ["X_IMAGE", "Y_IMAGE", "FWHM_IMAGE", "FLAGS"],
# config = {"DETECT_THRESH":200.0},
# sexpath = "sex"
# )
#
# out = findavgfwhm(image)["table"]
#
# fwhms = out['FWHM_IMAGE'] # This is an astropy table.
# flags = out['FLAGS']
# get a really rough estimate of the stellar FWHM in the image to set apertures
# use the input fwhm measurement
# ap1x = fwhm_est
# xpos = datatable['X_IMAGE']
# ypos = datatable['Y_IMAGE']
# fwhm = datatable['FWHM_IMAGE']
# flags = datatable['FLAGS']
# idno = datatable['NUMBER']
ap1x = np.median(
fwhm_good
) # only use isolated detections of stars, this is the 1x aperture
# print ap1x
ap2x = 2.0 * ap1x
# these = [ i for i,id in enumerate(idno) if (flags[i] == 0)]
# with open(image[0:-5]+'.escut.pos','w+') as f:
# for j in range(len(xpos)):
# print >> f, xpos[j], ypos[j], fwhm[j], idno[j]
iraf.datapars.setParam('fwhmpsf', ap1x)
iraf.photpars.setParam('apertures', repr(ap1x) + ', ' + repr(ap2x))
iraf.fitskypars.setParam('annulus', 4. * ap1x)
iraf.apphot.phot(image=image,
coords=pos_file,
output=image[0:-5] + '.phot')
with open(image[0:-5] + '.txdump', 'w+') as txdump_out:
iraf.ptools.txdump(
textfiles=image[0:-5] + '.phot',
fields=
"id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,image",
expr=
'MAG[1] != INDEF && MERR[1] != INDEF && MAG[2] != INDEF && MERR[2] != INDEF',
headers='no',
Stdout=txdump_out)
mag1x, mag2x = np.loadtxt(image[0:-5] + '.txdump',
usecols=(1, 2),
unpack=True)
iraf_id = np.loadtxt(image[0:-5] + '.txdump',
usecols=(0, ),
dtype=int,
unpack=True)
# idno = np.loadtxt(image[0:-5]+'.escut.pos', usecols=(3,), dtype=int, unpack=True)
xpos, ypos = np.loadtxt(pos_file, usecols=(0, 1), unpack=True)
keepIndex = iraf_id - 1
xpos, ypos, fwhm, peak = xpos[keepIndex], ypos[keepIndex], fwhm[
keepIndex], peak[keepIndex]
# print idno.size, iraf_id.size, xpos.size
diff = mag2x - mag1x
diffCut = diff
magCut = mag2x
xCut = xpos #[good]
yCut = ypos #[good]
idCut = iraf_id
fwhmCut = fwhm #_good
peakCut = peak
print(peakCut.size, magCut.size, diffCut.size)
print(diffCut.size, 0, np.median(diffCut), diffCut.std())
nRemoved = 1
# plt.clf()
# plt.scatter(peakCut, magCut, edgecolor='none')
# plt.savefig('peaktest.pdf')
plt.clf()
# plt.hlines(bin_edges, -2, 1, colors='red', linestyle='dashed')
plt.scatter(diff, mag2x, edgecolor='none', facecolor='black', s=4)
# plt.scatter(diffCut, magCut, edgecolor='none', facecolor='blue', s=4)
magdiff = list(
zip(magCut.tolist(), diffCut.tolist(), peakCut.tolist(),
idCut.tolist()))
dtype = [('mag', float), ('diff', float), ('peak', float), ('id', int)]
magdiff = np.array(magdiff, dtype=dtype)
magSort = np.sort(magdiff, order='peak')
peakRange = (magSort['peak'] > 20000.0) & (magSort['peak'] < 40000.0)
peakVal = np.median((magSort['diff'])[np.where(peakRange)])
# peakVal = np.median(diffCut)
print(peakVal)
plt.scatter((magSort['diff'])[np.where(peakRange)],
(magSort['mag'])[np.where(peakRange)],
edgecolor='none',
facecolor='blue',
s=4)
while nRemoved != 0:
nBefore = diffCut.size
diffCheck = np.where(
abs(peakVal - diffCut) < 2.0 *
diffCut.std()) #[i for i,d in enumerate(diff) if (-0.5 < d < 0.0)]
#
diffCut = diffCut[diffCheck]
nRemoved = nBefore - diffCut.size
magCut = magCut[diffCheck]
xCut = xCut[diffCheck]
yCut = yCut[diffCheck]
idCut = idCut[diffCheck]
fwhmCut = fwhmCut[diffCheck]
print(diffCut.size, nRemoved, np.median(diffCut), diffCut.std())
if 0.05 < diffCut.std() < 0.06:
nRemoved = 0
# plt.fill_betweenx(bin_centers, bin_meds+3.0*bin_stds, bin_meds-3.0*bin_stds, facecolor='red', edgecolor='none', alpha=0.4, label='2x RMS sigma clipping region')
# with open('escutSTD_i.pos','w+') as f:
# for i,blah in enumerate(xCut):
# print >> f, xCut[i], yCut[i], diffCut[i]
bin_meds, bin_edges, binnumber = stats.binned_statistic(magCut,
diffCut,
statistic='median',
bins=24,
range=(-12, 0))
bin_stds, bin_edges, binnumber = stats.binned_statistic(magCut,
diffCut,
statistic=np.std,
bins=24,
range=(-12, 0))
bin_width = (bin_edges[1] - bin_edges[0])
bin_centers = bin_edges[1:] - bin_width / 2
# print bin_meds, bin_stds
bin_hw = np.zeros_like(bin_stds)
for i, bin_std in enumerate(bin_stds):
if bin_std > 0.025:
bin_hw[i] = 3.0 * bin_std
else:
bin_hw[i] = 0.075
# print len(binnumber)
# for i,bin_hwi in enumerate(bin_hw):
left_edge = np.array(list(zip(peakVal - bin_hw, bin_centers)))
right_edge = np.flipud(np.array(list(zip(peakVal + bin_hw, bin_centers))))
# print left_edge, right_edge
verts = np.vstack((left_edge, right_edge))
# print verts
# verts = np.delete(verts, np.array([0,1,2,22,23,24,25,45,46,47]), axis=0)
# DON'T USE A PATH BECAUSE APPARENTLY IT CAN SELECT THE INVERSE SET!! WTF
# print verts
esRegion = Path(verts)
sources = esRegion.contains_points(list(zip(diff, mag2x)))
# print sources
with open('escutREG_i.pos', 'w+') as f:
for i, blah in enumerate(xpos[sources]):
print((xpos[sources])[i], (ypos[sources])[i], (diff[sources])[i],
file=f)
magCut2 = mag2x[sources]
magCut1 = mag1x[sources]
fwhmCut = fwhm[sources]
xCut = xpos[sources]
yCut = ypos[sources]
diffCut = diff[sources]
# find the sources that are in the std method but not the region method
# print idCut, idno[sources]
# extrasSTD = np.setdiff1d(idno[sources], idCut)
# print extrasSTD.size
# print extrasSTD
# with open('escutUNIQUE.pos','w+') as f:
# for i,blah in enumerate(extrasSTD):
# print >> f, xpos[blah-1], ypos[blah-1]
# fwhmcheck = np.loadtxt('testfwhmREG.log', usecols=(10,), unpack=True)
fwhmchk2 = np.where((magCut2 < -4) & (fwhmCut < 90.0))
print(np.median(fwhmCut[fwhmchk2]), np.std(fwhmCut[fwhmchk2]))
fwchk = np.where(
np.abs(fwhmCut - np.median(fwhmCut[fwhmchk2])) > 10.0 *
np.std(fwhmCut[fwhmchk2]))
drop = np.abs(fwhmCut - np.median(fwhmCut[fwhmchk2])) > 10.0 * np.std(
fwhmCut[fwhmchk2])
keep = np.abs(fwhmCut - np.median(fwhmCut[fwhmchk2])) <= 10.0 * np.std(
fwhmCut[fwhmchk2])
with open('escutVBAD_i.pos', 'w+') as f:
for i, blah in enumerate(xCut[fwchk]):
print((xCut[fwchk])[i], (yCut[fwchk])[i], file=f)
with open('escut_i.pos', 'w+') as f:
for i, blah in enumerate(xCut):
if not drop[i]:
print(xCut[i],
yCut[i],
magCut2[i],
fwhmCut[i],
magCut1[i],
file=f)
with open('escut_g.pos', 'w+') as f:
for i, blah in enumerate(xCut):
if not drop[i]:
print(xCut[i],
yCut[i],
magCut2[i],
fwhmCut[i],
magCut1[i],
file=f)
plt.fill_betweenx(bin_centers,
peakVal + bin_hw,
peakVal - bin_hw,
facecolor='red',
edgecolor='none',
alpha=0.4,
label='2x RMS sigma clipping region')
plt.scatter(diffCut[fwchk],
magCut2[fwchk],
edgecolor='none',
facecolor='red',
s=4)
plt.ylim(0, -12)
plt.xlabel('$m_{2x} - m_{1x}$')
plt.ylabel('$m_{2x}$')
plt.xlim(-2, 1)
plt.savefig('testmagiraf.pdf')
plt.clf()
plt.scatter(magCut2, fwhmCut, edgecolor='none', facecolor='black')
plt.scatter(magCut2[fwchk],
fwhmCut[fwchk],
edgecolor='none',
facecolor='red')
plt.hlines([np.median(fwhmCut)], -12, 0, colors='red', linestyle='dashed')
plt.hlines([
np.median(fwhmCut) + fwhmCut.std(),
np.median(fwhmCut) - fwhmCut.std()
],
-12,
0,
colors='red',
linestyle='dotted')
plt.ylim(0, 20)
plt.xlim(-12, 0)
plt.ylabel('fwhm')
plt.xlabel('$m_{2x}$')
plt.savefig('fwhmcheck.pdf')
return fwhmCut[keep]
def zeropoint_ota(img, ota, fwhm):
iraf.ptools(_doprint=0)
# otaext = {'33':1,'34':2,'44':3,'43':4,'42':5,'32':6,'22':7,'23':8,'24':9}
# values determined by ralf/daniel @ wiyn
kg = 0.20
kr = 0.12
ki = 0.058
# first grab the header and hang on to it so we can use other values
# hdulist = ast.io.fits.open(img)
# hdr = hdulist[ota].header
# hdulist.close()
image = odi.reprojpath+'reproj_'+ota+'.'+str(img[16:])
coords = odi.coordspath+'reproj_'+ota+'.'+str(img[16:-5])+'.sdssxy'
output = odi.coordspath+img[0:-5]+'.'+ota+'.phot.1'
phot_tbl = odi.coordspath+img[0:-5]+'.'+ota+'.sdssphot'
# alas, we must use IRAF apphot to do the measuring
# first set common parameters (these shouldn't change if you're using ODI)
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread',"rdnoise")
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
iraf.datapars.setParam('airmass','airmass')
iraf.datapars.setParam('fwhmpsf',fwhm)
iraf.photpars.setParam('apertures',3.*fwhm) # use a big aperture for this
iraf.fitskypars.setParam('annulus',4.*fwhm)
if not os.path.isfile(output):
iraf.apphot.phot(image=image, coords=coords, output=output)
with open(phot_tbl,'w+') as txdump_out :
iraf.ptools.txdump(textfiles=output, fields="id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,peak,flux,image", expr='yes', headers='no', Stdout=txdump_out)
outputfile_clean = open(phot_tbl.replace('.sdssphot','_clean.sdssphot'),"w")
for line in open(phot_tbl,"r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF','999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.sdssphot','_clean.sdssphot'),phot_tbl)
gMAG, gMERR, gSKY, gSERR, gRAPERT, gXPOS, gYPOS = np.loadtxt(phot_tbl, usecols=(1,2,3,4,5,6,7), dtype=float, unpack=True)
gXAIRMASS = np.loadtxt(phot_tbl, usecols=(9,), dtype=float, unpack=True)
gFILTER = np.loadtxt(phot_tbl, usecols=(8,), dtype=str, unpack=True)
gID = np.loadtxt(phot_tbl, usecols=(0,), dtype=int, unpack=True)
# keep the actual ID number to select from SDSS stars
keep = gID - 1
# read in the catalog values
x, y, ra, dec, u, ue, g, ge, r, re, i, ie, z, ze = np.loadtxt(coords, usecols=(0,1,2,3,4,5,6,7,8,9,10,11,12,13), unpack=True)
# pick out the ones that match the good phot stars
g, ge, r, re, i, ie = np.array(g[keep]), np.array(ge[keep]), np.array(r[keep]), np.array(re[keep]), np.array(i[keep]), np.array(ie[keep])
# and reduce the other vectors
# gXPOS, gYPOS, gMAG, gMERR, gSKY, gSERR = np.array(gXPOS[keep]), np.array(gYPOS[keep]), np.array(gMAG[keep]), np.array(gMERR[keep]), np.array(gSKY[keep]), np.array(gSERR[keep])
gXAIRMASS = gXAIRMASS[0]
gRAPERT = gRAPERT[0]
#podicut, sdsscut = 0.01, 0.03
podicut, sdsscut = 0.01, 0.10
# pick the right airmass extinction coefficient
kdict = {'odi_g':kg, 'odi_r':kr, 'odi_i':ki}
mdict = {'odi_g':g, 'odi_r':r, 'odi_i':i}
k = kdict[gFILTER[0]]
mag_cat = mdict[gFILTER[0]]
g0 = gMAG - k*gXAIRMASS
zp = mag_cat - g0
color = g - r
errcut = [j for j in range(len(gMERR)) if (gMERR[j] < podicut and ge[j] < sdsscut)]
if len(g0[errcut]) < 5:
print 'Too few stars for fit..'
return 999.999, 999.999, phot_tbl
else:
print 'fitting wtih '+repr(len(g0[errcut]))+' stars...'
# fit zero point
# linear lsq with numpy.polyfit
p, pcov = np.polyfit(color[errcut], zp[errcut], 1, cov=True)
perr = np.sqrt(np.diag(pcov))
eps_g, zp_g, std_eps_g, std_zp_g = p[0], p[1], perr[0], perr[1]
print '--------------------------------------------------------------------------'
print 'Here are the fit values:'
print 'eps '+' std_eps '+' zp '+' std_zp'
print '{0:10.7f} {1:10.7f} {2:10.7f} {3:10.7f}'.format(eps_g, std_eps_g, zp_g, std_zp_g)
star_zp_g = zp - eps_g*color
print 'std. dev. in ZP per star (not fit): {0:10.7f}'.format(np.std(star_zp_g[errcut]))
# for i in range(len(zp)):
# print color[i], zp[i], gMERR[i], ge[i]
print np.median(star_zp_g[errcut]), np.std(star_zp_g[errcut])
return np.median(star_zp_g[errcut]), np.std(star_zp_g[errcut]), phot_tbl
#/usr/bin/python/
#just like in IRAF, packages must be loaded
import sys, os, shutil, signal, math, types
from numpy import *
import pdb # python debugger
#numpy is the NUMber PYthon package that can do array math
from pyraf import iraf #,irafglobals
iraf.images()
iraf.imutil()
iraf.noao()
iraf.digiphot()
iraf.ptools()
iraf.daophot()
from easy_phot_params import *
#this loads all of the variables defined in easy_phot_params
def stringtohours(str):
hrs,mins,secs = map(float,str.split(":"))
return hrs+mins/60. + secs/3600.
def execute():
#here we define the coords variable as a list
coords=[]
#indenting matters in python. Everything
def main(argv):
home_root = os.environ['HOME']
iraf.images(_doprint=0)
iraf.tv(_doprint=0)
iraf.ptools(_doprint=0)
iraf.noao(_doprint=0)
iraf.digiphot(_doprint=0)
iraf.photcal(_doprint=0)
iraf.apphot(_doprint=0)
iraf.imutil(_doprint=0)
for file_ in os.listdir("./"):
if file_.endswith("_i.fits"):
fits_file_i = file_
title_string = file_[0:9]
if file_.endswith("_g.fits"):
fits_file_g = file_
fits_h_i = fits.open(fits_file_i)
fits_h_g = fits.open(fits_file_g)
fwhm_i = fits_h_i[0].header['FWHMPSF']
fwhm_g = fits_h_g[0].header['FWHMPSF']
print 'Image FWHM :: g = {0:5.3f} : i = {1:5.3f}'.format(fwhm_g,fwhm_i)
# if not os.path.isdir('psf'): # make a psf subfolder if it doesn't exist
# os.mkdir('psf')
# # and then copy in the data files if they don't already exist as files
# if not os.path.isfile('psf/'+fits_file_i):
# iraf.images.imcopy(fits_file_i,'psf/'+fits_file_i,verbose="yes")
#
# if not os.path.isfile('psf/'+fits_file_g) :
# iraf.images.imcopy(fits_file_g,'psf/'+fits_file_g,verbose="yes")
#
# # also copy in the apcor star lists
# if not (os.path.isfile('psf/apcor_stars_i.txt') or os.path.islink('psf/apcor_stars_i.txt')) :
# shutil.copyfile('apcor_stars_i.txt','psf/apcor_stars_i.txt')
#
# if not (os.path.isfile('psf/apcor_stars_g.txt') or os.path.islink('psf/apcor_stars_g.txt')) :
# shutil.copyfile('apcor_stars_g.txt','psf/apcor_stars_g.txt')
#
# # and change to the psf folder
# os.chdir('psf')
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',"INDEF")
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread',"rdnoise")
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('airmass',"airmass")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
iraf.datapars.setParam('fwhmpsf',fwhm_g)
iraf.photpars.setParam('apertures',iraf.nint(4.*fwhm_g))
iraf.fitskypars.setParam('annulus',(6.*fwhm_g))
iraf.apphot.phot(image=fits_file_g, coords='apcor_stars_g.txt', output="g_psfstars.mag.1")
iraf.datapars.setParam('fwhmpsf',fwhm_i)
iraf.photpars.setParam('apertures',iraf.nint(4.*fwhm_i))
iraf.fitskypars.setParam('annulus',(6.*fwhm_i))
iraf.apphot.phot(image=fits_file_i, coords='apcor_stars_i.txt', output="i_psfstars.mag.1")
with open("apcor_stars_i.txt") as foo:
lines = len(foo.readlines())
iraf.daophot(_doprint=0)
iraf.pstselect.setParam('image',fits_file_i)
iraf.pstselect.setParam('photfile',"i_psfstars.mag.1")
iraf.pstselect.setParam('pstfile',"default")
iraf.pstselect.setParam('maxnpsf',lines)
iraf.pstselect.setParam('plottype',"mesh")
iraf.daophot.pstselect(verify='no', mode='h')
with open("apcor_stars_g.txt") as foo:
lines = len(foo.readlines())
iraf.pstselect.setParam('image',fits_file_g)
iraf.pstselect.setParam('photfile',"g_psfstars.mag.1")
iraf.pstselect.setParam('pstfile',"default")
iraf.pstselect.setParam('maxnpsf',lines)
iraf.pstselect.setParam('plottype',"mesh")
iraf.daophot.pstselect()
iraf.datapars.setParam('datamax',"INDEF")
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread',"rdnoise")
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('airmass',"airmass")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.daopars.setParam('psfrad',iraf.nint(3.*fwhm_i))
iraf.daopars.setParam('fitrad',fwhm_i)
iraf.psf.setParam('image',fits_file_i)
iraf.psf.setParam('photfile',"i_psfstars.mag.1")
iraf.psf.setParam('pstfile',fits_file_i+".pst.1")
iraf.psf.setParam('interactive', 'no')
iraf.daophot.psf()
iraf.psf.setParam('image',fits_file_g)
iraf.psf.setParam('photfile',"g_psfstars.mag.1")
iraf.psf.setParam('pstfile',fits_file_g+".pst.1")
iraf.psf.setParam('interactive', 'no')
iraf.daophot.psf()
# select the top 15 brightest stars and find the translation between images
for current_object in objects_need_aligning:
print "Current object", current_object
# Open files to store data that imalign will need later on
obj_list = open(current_object + ".lis", "w")
shifts_list = open(current_object + ".shifts", "w")
coords_list = open(current_object + ".coords","w")
output_list = open(current_object + ".out", "w")
# All images of this object. Read fiirst as reference
whr = np.where(list_images["objname"] == current_object)[0]
ref_im = list_images["filename"][whr[0]]
ref_catalog = utilities.replace_extension(ref_im, ".cat")
# Txdump writes to a temporary file, then we read it
iraf.ptools(_doprint=0)
if os.path.isfile("temp.txt"):
os.remove("temp.txt")
iraf.txdump(ref_catalog, "xcenter, ycenter, mag", "yes", Stdout="temp.txt")
x_ref=y_ref=mag_ref=np.array([],dtype=np.float16)
with open("temp.txt") as f:
for line in f:
x_ref = np.append(x_ref,float(line.split()[0]))
y_ref = np.append(y_ref,float(line.split()[1]))
mag_ref = np.append(mag_ref, float(line.split()[2]))
brightest_stars = np.argsort(mag_ref)[:nstars]
x_ref = x_ref[brightest_stars]
y_ref = y_ref[brightest_stars]
#Write to a file, which imalign will need later
for ii,jj in zip(x_ref,y_ref):
def escut(image, pos_file, fwhm, peak):
# input image file name, file name with matched source positions, **np.array of fwhm measurements for each source
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from pyraf import iraf
# import sewpy
import os
from matplotlib.path import Path
iraf.images(_doprint=0)
iraf.tv(_doprint=0)
iraf.ptools(_doprint=0)
iraf.noao(_doprint=0)
iraf.digiphot(_doprint=0)
iraf.photcal(_doprint=0)
iraf.apphot(_doprint=0)
iraf.imutil(_doprint=0)
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread',"rdnoise")
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('airmass',"airmass")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
# iraf.datapars.setParam('obstime',"date-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
# clean up the indefs so we can actually do stats, but reassign them to 99999 so we don't lose track of things
# keep a separate list without them to do the median (we need floats)
indefs = np.where(fwhm=='INDEF')
good = np.where(fwhm!='INDEF')
fwhm[indefs] = 99.999
fwhm = fwhm.astype(float)
fwhm_good = fwhm[good].astype(float)
indefs = np.where(peak=='INDEF')
peak[indefs] = -999.999
peak = peak.astype(float)
peak_good = peak[good].astype(float)
if not os.path.isfile(image[0:-5]+'.txdump'):
# findavgfwhm = sewpy.SEW(
# params = ["X_IMAGE", "Y_IMAGE", "FWHM_IMAGE", "FLAGS"],
# config = {"DETECT_THRESH":200.0},
# sexpath = "sex"
# )
#
# out = findavgfwhm(image)["table"]
#
# fwhms = out['FWHM_IMAGE'] # This is an astropy table.
# flags = out['FLAGS']
# get a really rough estimate of the stellar FWHM in the image to set apertures
# use the input fwhm measurement
# ap1x = fwhm_est
# xpos = datatable['X_IMAGE']
# ypos = datatable['Y_IMAGE']
# fwhm = datatable['FWHM_IMAGE']
# flags = datatable['FLAGS']
# idno = datatable['NUMBER']
ap1x = np.median(fwhm_good) # only use isolated detections of stars, this is the 1x aperture
# print ap1x
ap2x = 2.0*ap1x
# these = [ i for i,id in enumerate(idno) if (flags[i] == 0)]
# with open(image[0:-5]+'.escut.pos','w+') as f:
# for j in range(len(xpos)):
# print >> f, xpos[j], ypos[j], fwhm[j], idno[j]
iraf.datapars.setParam('fwhmpsf',ap1x)
iraf.photpars.setParam('apertures',repr(ap1x)+', '+repr(ap2x))
iraf.fitskypars.setParam('annulus',4.*ap1x)
iraf.apphot.phot(image=image, coords=pos_file, output=image[0:-5]+'.phot')
with open(image[0:-5]+'.txdump','w+') as txdump_out :
iraf.ptools.txdump(textfiles=image[0:-5]+'.phot', fields="id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,image", expr='MAG[1] != INDEF && MERR[1] != INDEF && MAG[2] != INDEF && MERR[2] != INDEF', headers='no', Stdout=txdump_out)
mag1x, mag2x = np.loadtxt(image[0:-5]+'.txdump', usecols=(1,2), unpack=True)
iraf_id = np.loadtxt(image[0:-5]+'.txdump', usecols=(0,), dtype=int, unpack=True)
# idno = np.loadtxt(image[0:-5]+'.escut.pos', usecols=(3,), dtype=int, unpack=True)
xpos, ypos = np.loadtxt(pos_file, usecols=(0,1), unpack=True)
keepIndex = iraf_id - 1
xpos, ypos, fwhm, peak = xpos[keepIndex], ypos[keepIndex], fwhm[keepIndex], peak[keepIndex]
# print idno.size, iraf_id.size, xpos.size
diff = mag2x - mag1x
diffCut = diff
magCut = mag2x
xCut = xpos#[good]
yCut = ypos#[good]
idCut = iraf_id
fwhmCut = fwhm#_good
peakCut = peak
print peakCut.size, magCut.size, diffCut.size
print diffCut.size, 0, np.median(diffCut), diffCut.std()
nRemoved = 1
# plt.clf()
# plt.scatter(peakCut, magCut, edgecolor='none')
# plt.savefig('peaktest.pdf')
plt.clf()
# plt.hlines(bin_edges, -2, 1, colors='red', linestyle='dashed')
plt.scatter(diff, mag2x, edgecolor='none', facecolor='black', s=4)
# plt.scatter(diffCut, magCut, edgecolor='none', facecolor='blue', s=4)
magdiff = zip(magCut.tolist(), diffCut.tolist(), peakCut.tolist(), idCut.tolist())
dtype = [('mag',float), ('diff', float), ('peak', float), ('id', int)]
magdiff = np.array(magdiff, dtype=dtype)
magSort = np.sort(magdiff, order='peak')
peakRange = (magSort['peak'] > 20000.0) & (magSort['peak'] < 40000.0)
peakVal = np.median((magSort['diff'])[np.where(peakRange)])
# peakVal = np.median(diffCut)
print peakVal
plt.scatter((magSort['diff'])[np.where(peakRange)], (magSort['mag'])[np.where(peakRange)], edgecolor='none', facecolor='blue', s=4)
while nRemoved != 0:
nBefore = diffCut.size
diffCheck = np.where(abs(peakVal-diffCut) < 2.5*diffCut.std())#[i for i,d in enumerate(diff) if (-0.5 < d < 0.0)]
#
diffCut = diffCut[diffCheck]
nRemoved = nBefore - diffCut.size
magCut = magCut[diffCheck]
xCut = xCut[diffCheck]
yCut = yCut[diffCheck]
idCut = idCut[diffCheck]
fwhmCut = fwhmCut[diffCheck]
print diffCut.size, nRemoved, np.median(diffCut), diffCut.std()
if 0.05 < diffCut.std() <0.06:
nRemoved=0
# plt.fill_betweenx(bin_centers, bin_meds+3.0*bin_stds, bin_meds-3.0*bin_stds, facecolor='red', edgecolor='none', alpha=0.4, label='2x RMS sigma clipping region')
# with open('escutSTD_i.pos','w+') as f:
# for i,blah in enumerate(xCut):
# print >> f, xCut[i], yCut[i], diffCut[i]
bin_meds, bin_edges, binnumber = stats.binned_statistic(magCut, diffCut, statistic='median', bins=24, range=(magCut.min(),magCut.max()))
bin_stds, bin_edges, binnumber = stats.binned_statistic(magCut, diffCut, statistic=np.std, bins=24, range=(magCut.min(),magCut.max()))
bin_width = (bin_edges[1] - bin_edges[0])
bin_centers = bin_edges[1:] - bin_width/2
# print bin_meds, bin_stds
left_edge = np.array(zip(peakVal-2.5*bin_stds, bin_centers))
right_edge = np.flipud(np.array(zip(peakVal+2.5*bin_stds, bin_centers)))
# print left_edge, right_edge
verts = np.vstack((left_edge, right_edge))
# print verts
# verts = np.delete(verts, np.array([0,1,2,22,23,24,25,45,46,47]), axis=0)
# print verts
esRegion = Path(verts)
sources = esRegion.contains_points(zip(diff,mag2x))
# print sources
with open('escutREG_i.pos','w+') as f:
for i,blah in enumerate(xpos[sources]):
print >> f, (xpos[sources])[i], (ypos[sources])[i], (diff[sources])[i]
magCut = mag2x[sources]
fwhmCut = fwhm[sources]
xCut = xpos[sources]
yCut = ypos[sources]
diffCut = diff[sources]
# find the sources that are in the std method but not the region method
# print idCut, idno[sources]
# extrasSTD = np.setdiff1d(idno[sources], idCut)
# print extrasSTD.size
# print extrasSTD
# with open('escutUNIQUE.pos','w+') as f:
# for i,blah in enumerate(extrasSTD):
# print >> f, xpos[blah-1], ypos[blah-1]
# fwhmcheck = np.loadtxt('testfwhmREG.log', usecols=(10,), unpack=True)
fwhmchk2 = np.where((magCut<-4) & (fwhmCut<90.0))
print np.median(fwhmCut[fwhmchk2]), np.std(fwhmCut[fwhmchk2])
fwchk = np.where(np.abs(fwhmCut-np.median(fwhmCut[fwhmchk2])) > 10.0*np.std(fwhmCut[fwhmchk2]))
drop = np.abs(fwhmCut-np.median(fwhmCut[fwhmchk2])) > 10.0*np.std(fwhmCut[fwhmchk2])
# fwmag = mag2x[sources]
with open('escutVBAD_i.pos','w+') as f:
for i,blah in enumerate(xCut[fwchk]):
print >> f, (xCut[fwchk])[i], (yCut[fwchk])[i]
with open('escut_r.pos','w+') as f:
for i,blah in enumerate(xCut):
if not drop[i]:
print >> f, xCut[i], yCut[i]
with open('escut_g.pos','w+') as f:
for i,blah in enumerate(xCut):
if not drop[i]:
print >> f, xCut[i], yCut[i]
plt.fill_betweenx(bin_centers, peakVal+2.5*bin_stds, peakVal-2.5*bin_stds, facecolor='red', edgecolor='none', alpha=0.4, label='2x RMS sigma clipping region')
plt.scatter(diffCut[fwchk], magCut[fwchk], edgecolor='none', facecolor='red', s=4)
plt.ylim(0,-12)
plt.xlabel('$m_{2x} - m_{1x}$')
plt.ylabel('$m_{2x}$')
plt.xlim(-2,1)
plt.savefig('testmagiraf.pdf')
plt.clf()
plt.scatter(magCut, fwhmCut, edgecolor='none', facecolor='black')
plt.scatter(magCut[fwchk], fwhmCut[fwchk], edgecolor='none', facecolor='red')
plt.hlines([np.median(fwhmCut)], -12, 0, colors='red', linestyle='dashed')
plt.hlines([np.median(fwhmCut)+fwhmCut.std(), np.median(fwhmCut)-fwhmCut.std()], -12, 0, colors='red', linestyle='dotted')
plt.ylim(0,20)
plt.xlim(-12,0)
plt.ylabel('fwhm')
plt.xlabel('$m_{2x}$')
plt.savefig('fwhmcheck.pdf')
return True
for current_object in objects_need_aligning:
print "Current object", current_object
# Open files to store data that imalign will need later on
obj_list = open(current_object + ".lis", "w")
shifts_list = open(current_object + ".shifts", "w")
coords_list = open(current_object + ".coords","w")
output_list = open(current_object + ".out", "w")
# All images of this object. Read fiirst as reference
whr = np.where(list_images["objname"] == current_object)[0]
ref_im = list_images["filename"][whr[0]]
ref_catalog = utilities.replace_extension(ref_im, ".cat")
# Txdump writes to a temporary file, then we read it
iraf.ptools(_doprint=0)
if os.path.isfile("temp.txt"):
os.remove("temp.txt")
iraf.txdump(ref_catalog, "xcenter, ycenter, mag", "yes", Stdout="temp.txt")
x_ref=y_ref=mag_ref=np.array([],dtype=np.float16)
with open("temp.txt") as f:
for line in f:
x_ref = np.append(x_ref,float(line.split()[0]))
y_ref = np.append(y_ref,float(line.split()[1]))
mag_ref = np.append(mag_ref, float(line.split()[2]))
brightest_stars = np.argsort(mag_ref)[:nstars]
x_ref = x_ref[brightest_stars]
y_ref = y_ref[brightest_stars]
#Write to a file, which imalign will need later
for ii,jj in zip(x_ref,y_ref):
coords_list.write( str(ii) + " " + str(jj) + "\n")
def phot_sources(img, ota, fwhm, run_detect=True):
"""
Run IRAF phot on the sources filtered by :py:func:`source_xy`. The ``fwhm``
values used by phot is calculated by :py:func:`getfwhm_source`.
Parameters
----------
img : str
Name of image
ota : str
Name of OTA
fwhm : float
Median value of the ``gfwhm`` measurements on the ``ota``.
Note
----
IRAF phot is run with the following parameters:
- iraf.apphot.phot.setParam('interactive',"no")
- iraf.apphot.phot.setParam('verify',"no")
- iraf.datapars.setParam('datamax',50000.)
- iraf.datapars.setParam('gain',"gain")
- iraf.datapars.setParam('ccdread',"rdnoise")
- iraf.datapars.setParam('exposure',"exptime")
- iraf.datapars.setParam('filter',"filter")
- iraf.datapars.setParam('obstime',"time-obs")
- iraf.datapars.setParam('sigma',"INDEF")
- iraf.photpars.setParam('zmag',0.)
- iraf.centerpars.setParam('cbox',9.)
- iraf.centerpars.setParam('maxshift',3.)
- iraf.fitskypars.setParam('salgorithm',"median")
- iraf.fitskypars.setParam('dannulus',10.)
- iraf.datapars.setParam('airmass','airmass')
- iraf.datapars.setParam('fwhmpsf',fwhm)
- iraf.photpars.setParam('apertures',5.*fwhm)
- iraf.fitskypars.setParam('annulus',6.*fwhm)
"""
iraf.ptools(_doprint=0)
# values determined by ralf/daniel @ wiyn
kg = 0.20
kr = 0.12
ki = 0.058
image = odi.reprojpath + 'reproj_' + ota + '.' + img.stem()
if run_detect == True:
coords = odi.sourcepath + 'source_' + ota + '.' + img.base() + '.xy'
else:
coords = odi.coordspath + 'reproj_' + ota + '.' + img.base(
) + '.gaiaxy'
output = odi.sourcepath + img.nofits() + '.' + ota + '.phot.1'
phot_tbl = odi.sourcepath + img.nofits() + '.' + ota + '.sourcephot'
# alas, we must use IRAF apphot to do the measuring
# first set common parameters (these shouldn't change if you're using ODI)
iraf.unlearn(iraf.phot, iraf.datapars, iraf.photpars, iraf.centerpars,
iraf.fitskypars)
iraf.apphot.phot.setParam('interactive', "no")
iraf.apphot.phot.setParam('verify', "no")
iraf.datapars.setParam('datamax', 50000.)
iraf.datapars.setParam('gain', "gain")
iraf.datapars.setParam('ccdread', "rdnoise")
iraf.datapars.setParam('exposure', "exptime")
iraf.datapars.setParam('filter', "filter")
iraf.datapars.setParam('obstime', "time-obs")
iraf.datapars.setParam('sigma', "INDEF")
iraf.photpars.setParam('zmag', 0.)
iraf.centerpars.setParam('cbox', 9.)
iraf.centerpars.setParam('maxshift', 3.)
iraf.fitskypars.setParam('salgorithm', "median")
iraf.fitskypars.setParam('dannulus', 10.)
iraf.datapars.setParam('airmass', 'airmass')
iraf.datapars.setParam('fwhmpsf', fwhm)
iraf.photpars.setParam('apertures',
5. * fwhm) # use a big aperture for this
iraf.fitskypars.setParam('annulus', 6. * fwhm)
if not os.path.isfile(output):
iraf.apphot.phot(image=image, coords=coords, output=output)
with open(phot_tbl, 'w+') as txdump_out:
iraf.ptools.txdump(
textfiles=output,
fields=
"id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,itime,flux,image",
expr='yes',
headers='no',
Stdout=txdump_out)
outputfile_clean = open(
phot_tbl.replace('.sourcephot', '_clean.sourcephot'), "w")
for line in open(phot_tbl, "r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF', '999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.sourcephot', '_clean.sourcephot'), phot_tbl)
return phot_tbl
def apcor_sdss(img, fwhm, inspect=False):
"""
Determine the aperture correction based on the photometry of SDSS sources in
the field. Each SDSS source is ``phot-ed`` with a range of apertures that
are multiples of the mean ``fwhm`` of SDSS stars in the field. Specifically,
``phot`` is done using ``1 - 7*fwhm`` in steps of ``0.5``. This function
calculates the difference in the instrumental magnitude in aperture 'n'
with aperture ``n-1``. The aperture at which this difference levels off is
where we determine what the aperture correction is. This is typically around
``4.5 to 5*fwhm``, but can vary depending on the data. This difference
between this leveling off point, and the magnitude measured using ``1*fwhm``
is the returned aperture correction. Sigma clipping is used to throw out
values that would throw off the measurement.
Parameters
----------
img : str
String containing name of the image currently in us
fhwm : float
average of median fwhm of SDSS sources in the field
inspect : boolean
if ``True`` each candidate aperture correction star will be
displayed. This gives you the chance to throw out stars that
have near neighbors or next to image artifacts.
Returns
-------
apcor : float
mean aperture correction of candidate starts remaining After
sigma clipping
apcor_std : float
standard deviation of aperture corrections of candidate starts
remaining After sigma clipping
apcor_sem : float
standard error on the mean of the aperture corrections of
candidate starts remaining After sigma clipping
"""
from pyraf import iraf
import matplotlib.pyplot as plt
from scipy import interpolate
from matplotlib.colors import LogNorm
from astropy.visualization import *
from astropy.visualization.mpl_normalize import ImageNormalize
iraf.ptools(_doprint=0)
sdss_source_file = img.nofits() + '.match.sdssxy'
sdss_phot_file = img.nofits() + '.sdssphot'
sdss_MAG, sdss_MERR, sdss_SKY, sdss_SERR, sdss_RAPERT, sdss_XPOS, sdss_YPOS = np.loadtxt(
img.nofits() + '.sdssphot',
usecols=(1, 2, 3, 4, 5, 6, 7),
dtype=float,
unpack=True)
x, y, ra, dec, g, g_err, r, r_err = np.loadtxt(sdss_source_file,
usecols=(0, 1, 2, 3, 6, 7,
8, 9),
unpack=True)
peak, gfwhm = getfwhm_full_sdss(img)
#odi.plt.figure()
#odi.plt.hist(peak[np.where(g < 19)])
#odi.plt.figure()
#odi.plt.hist(gfwhm[np.where(g < 19)])
#odi.plt.show()
#plt.clf()
#plt.hist(peak[np.where(peak > 12000.0)])
#plt.show()
aps = []
for i in np.arange(1, 7.5, 0.5):
aps.append(fwhm * i)
#aps = np.ones(13)*5.0
aps_str = str('"' + repr(aps[0]) + ',' + repr(aps[1]) + ',' +
repr(aps[2]) + ',' + repr(aps[3]) + ',' + repr(aps[4]) +
',' + repr(aps[5]) + ',' + repr(aps[6]) + ',' +
repr(aps[7]) + ',' + repr(aps[8]) + ',' + repr(aps[9]) +
',' + repr(aps[10]) + ',' + repr(aps[11]) + ',' +
repr(aps[12]) + '"')
hdulist = odi.fits.open(img.f)
hdr1 = hdulist[0].header
data = hdulist[0].data
filter = hdr1['filter']
hdulist.close()
iraf.unlearn(iraf.phot, iraf.datapars, iraf.photpars, iraf.centerpars,
iraf.fitskypars)
iraf.apphot.phot.setParam('interactive', "no")
iraf.apphot.phot.setParam('verify', "no")
iraf.datapars.setParam('datamax', 50000.)
iraf.datapars.setParam('gain', "gain")
iraf.datapars.setParam('ccdread', 'rdnoise')
iraf.datapars.setParam('exposure', "exptime")
#iraf.datapars.setParam('itime',2700.0)
iraf.datapars.setParam('filter', "filter")
iraf.datapars.setParam('obstime', "time-obs")
iraf.datapars.setParam('sigma', "INDEF")
iraf.photpars.setParam('zmag', 0.)
iraf.centerpars.setParam('cbox', 9.)
iraf.centerpars.setParam('maxshift', 3.)
iraf.fitskypars.setParam('salgorithm', "median")
iraf.fitskypars.setParam('dannulus', 10.)
phot_tbl = img.nofits() + '.apcor'
if not os.path.isfile(phot_tbl):
print 'running phot over', aps_str
iraf.datapars.setParam('fwhmpsf', fwhm)
iraf.photpars.setParam('apertures', aps_str)
iraf.fitskypars.setParam('annulus', 6. * float(fwhm))
iraf.apphot.phot(image=img,
coords=sdss_source_file,
output=img.nofits() + '.apcor.1')
with open(phot_tbl, 'w+') as txdump_out:
iraf.ptools.txdump(textfiles=img.nofits() + '.apcor.1',
fields="ID,RAPERT,XCEN,YCEN,FLUX,MAG,MERR",
expr="yes",
headers='no',
Stdout=txdump_out)
txdump_out.close()
outputfile_clean = open(phot_tbl.replace('.apcor', '_clean.apcor'),
"w")
for line in open(phot_tbl, "r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF', '999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.apcor', '_clean.apcor'), phot_tbl)
peak_top1per = 49000.0
star_flux = {}
star_mag_diff = {}
star_mag_diff1x = {}
star_mag = {}
star_positions = {}
for i, line in enumerate(open(img.nofits() + '.apcor', "r")):
flux = [float(x) for x in line.split()[16:29]]
mag = [float(x) for x in line.split()[29:42]]
err = [float(x) for x in line.split()[42:55]]
position = [float(x) for x in line.split()[14:16]]
#print i,peak[i],gfwhm[i],g[i]
if (peak[i] > 2500.0 and peak[i] <= 55000.0 and
(np.abs(gfwhm[i] - np.median(gfwhm[np.where(gfwhm < 20.0)])) <
np.std(gfwhm[np.where(gfwhm < 20.0)])) and np.max(mag) != 999.0):
if inspect == True:
center = position
x1 = center[0] - 75
x2 = center[0] + 75
y1 = center[1] - 75
y2 = center[1] + 75
box = data[y1:y2, x1:x2]
plt.figure()
norm = ImageNormalize(stretch=LogStretch())
odi.plt.imshow(box, norm=norm)
max_count = np.max(box)
odi.plt.title('max counts =' + str(max_count))
plt.show()
star_check = raw_input('Use star for ap correction: (y/n) ')
if star_check == 'y':
star_flux[i] = flux
star_mag[i] = mag
star_positions[i] = position
else:
star_positions[i] = position
star_flux[i] = flux
star_mag[i] = mag
for key in star_mag:
diffs = []
diffs1x = []
for m in range(len(star_mag[key]) - 1):
diffs.append(star_mag[key][m + 1] - star_mag[key][m])
diffs1x.append(star_mag[key][m] - star_mag[key][0])
#print star_mag[key][8],star_mag[key][0]
star_mag_diff[key] = diffs
star_mag_diff1x[key] = diffs1x
combine_mag_diffs = []
combine_mag_diffs1x = []
for key in star_mag_diff:
x = np.arange(1, 7.0, 0.5)
y = star_mag_diff[key]
z = star_mag_diff1x[key]
#plt.plot(x,y,'o')
#plt.show()
combine_mag_diffs.append(y)
combine_mag_diffs1x.append(z)
#tck = interpolate.splrep(x, y, s=0)
#xnew = np.arange(1,6,0.25)
#ynew = interpolate.splev(xnew,tck,der=1)
#print len(np.arange(1,6.5,0.5)),len(star_mag_diff[key])
#plt.plot(np.arange(1,6.5,0.5),star_mag_diff[key],'o')
#plt.plot(xnew,ynew,'-')
#plt.axhline(y=0)
#plt.show()
combine_mag_diffs = np.reshape(combine_mag_diffs,
(len(star_mag_diff.keys()), len(x)))
combine_mag_diffs_med = []
combine_mag_diffs_std = []
combine_mag_diffs1x = np.reshape(combine_mag_diffs1x,
(len(star_mag_diff1x.keys()), len(x)))
combine_mag_diffs1x_mean = []
combine_mag_diffs1x_med = []
combine_mag_diffs1x_std = []
combine_mag_diffs1x_sem = []
for j in range(len(x)):
if j != 0:
star_test = combine_mag_diffs1x[:, j]
star_test = star_test[np.where(
((star_test >= -0.5) & (star_test <= 0)))]
sig_test = np.std(combine_mag_diffs1x[:, j])
#print sig_test,len(star_test)
med_test = np.median(combine_mag_diffs1x[:, j])
keep = star_test[np.where(np.abs(star_test - med_test) < 0.01)]
#plt.hist(keep)
#plt.show()
combine_mag_diffs1x_mean.append(np.mean(keep))
combine_mag_diffs1x_med.append(np.median(keep))
combine_mag_diffs1x_std.append(np.std(keep))
combine_mag_diffs1x_sem.append(np.std(keep) / np.sqrt(len(keep)))
if j == 8:
print 'using ', len(keep), 'stars in ap correction'
else:
combine_mag_diffs1x_mean.append(np.mean(combine_mag_diffs1x[:, j]))
combine_mag_diffs1x_med.append(np.median(combine_mag_diffs1x[:,
j]))
combine_mag_diffs1x_std.append(np.std(combine_mag_diffs1x[:, j]))
combine_mag_diffs1x_sem.append(
np.std(combine_mag_diffs1x[:, j]) /
np.sqrt(len(combine_mag_diffs1x[:, j])))
combine_mag_diffs_med.append(np.median(combine_mag_diffs[:, j]))
combine_mag_diffs_std.append(np.std(combine_mag_diffs[:, j]))
tck = interpolate.splrep(x, combine_mag_diffs_med, s=0)
xnew = np.arange(1, 7.0, 0.25)
ynew = interpolate.splev(xnew, tck, der=0)
ynew_der = interpolate.splev(xnew, tck, der=1)
plt.figure(figsize=(14, 7))
ax1 = plt.subplot(121)
ax2 = plt.subplot(122)
ax1.errorbar(x,
combine_mag_diffs_med,
yerr=combine_mag_diffs_std,
fmt='o',
label='Median mag. Diff.')
ax1.plot(xnew, ynew, 'r-', label='Spline fit')
ax1.set_ylabel('Mag(n+1) - Mag(n)')
ax1.set_xlabel('n $ \cdot $ fwhm')
ax2.plot(xnew, ynew_der, 'r-')
ax2.axhline(y=0)
ax2.set_ylabel('Value of Spline 1st Derivative')
ax2.set_xlabel('n $ \cdot $ fwhm')
ax1.legend(loc=4)
plt.tight_layout()
plt.show()
# print combine_mag_diffs1x_mean
# print combine_mag_diffs1x_std
# print combine_mag_diffs1x_sem
for i in range(len(x)):
plt.errorbar(x[i],
combine_mag_diffs1x_mean[i],
yerr=combine_mag_diffs1x_std[i],
fmt='bo')
plt.ylim(-0.45, 0.1)
plt.xlim(-0.1, 7.5)
plt.xlabel('n fwhm')
plt.ylabel('ap correction')
plt.show()
#apcor = np.median(combine_mag_diffs1x_mean[5:10:1])
apcor = combine_mag_diffs1x_mean[8]
apcor_std = combine_mag_diffs1x_std[8]
apcor_sem = combine_mag_diffs1x_sem[8]
apcor_med = combine_mag_diffs1x_med[8]
print 'aperture corr. = {0:6.3f}'.format(apcor)
print 'aperture corr. med. = {0:6.3f}'.format(apcor_med)
print 'aperture corr. std = {0:6.3f}'.format(apcor_std)
print 'aperture corr. sem = {0:6.3f}'.format(apcor_sem)
return apcor, apcor_std, apcor_sem
def sdss_phot_full(img, fwhm, airmass):
"""
Run ``pyraf phot`` on SDSS sources in the field. ``phot`` is given the
following parameters ::
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread','rdnoise')
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
iraf.datapars.setParam('xairmass',float(airmass))
iraf.datapars.setParam('fwhmpsf',float(fwhm))
iraf.photpars.setParam('apertures',5.*float(fwhm)) # use a big aperture for this
iraf.fitskypars.setParam('annulus',6.*float(fwhm))
Parameters
----------
img : str
String containing name of the image currently in use
fwhm : float
A measure of the fwhm of stars in the stacked image
airmass : float
Airmass assigned to the stacked image. Should match the image in the
dither that was used as the reference scaling image.
"""
from pyraf import iraf
iraf.ptools(_doprint=0)
# first grab the header and hang on to it so we can use other values
hdulist = odi.fits.open(img.f)
hdr1 = hdulist[0].header
filter = hdr1['filter']
hdulist.close()
iraf.unlearn(iraf.phot, iraf.datapars, iraf.photpars, iraf.centerpars,
iraf.fitskypars)
iraf.apphot.phot.setParam('interactive', "no")
iraf.apphot.phot.setParam('verify', "no")
iraf.datapars.setParam('datamax', 50000.)
iraf.datapars.setParam('gain', "gain")
iraf.datapars.setParam('ccdread', 'rdnoise')
iraf.datapars.setParam('exposure', "exptime")
iraf.datapars.setParam('filter', "filter")
iraf.datapars.setParam('obstime', "time-obs")
iraf.datapars.setParam('sigma', "INDEF")
iraf.photpars.setParam('zmag', 0.)
iraf.centerpars.setParam('cbox', 9.)
iraf.centerpars.setParam('maxshift', 3.)
iraf.fitskypars.setParam('salgorithm', "median")
iraf.fitskypars.setParam('dannulus', 10.)
if not os.path.isfile(img.nofits() + '.sdssphot'): # only do this once
print 'phot-ing the sdss sources in ', filter
iraf.datapars.setParam('xairmass', float(airmass))
iraf.datapars.setParam('fwhmpsf', float(fwhm))
iraf.photpars.setParam('apertures',
5. * float(fwhm)) # use a big aperture for this
iraf.fitskypars.setParam('annulus', 6. * float(fwhm))
iraf.apphot.phot(image=img,
coords=img.nofits() + '.match.sdssxy',
output=img.nofits() + '.phot.1')
phot_tbl = img.nofits() + '.sdssphot'
with open(phot_tbl, 'w+') as txdump_out:
iraf.ptools.txdump(
textfiles=img.nofits() + '.phot.1',
fields=
"id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,image",
expr='yes',
headers='no',
Stdout=txdump_out)
outputfile_clean = open(
phot_tbl.replace('.sdssphot', '_clean.sdssphot'), "w")
for line in open(phot_tbl, "r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF', '999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.sdssphot', '_clean.sdssphot'), phot_tbl)
def apcor_sdss(img,fwhm,inspect=False):
"""
Determine the aperture correction based on the photometry of SDSS sources in
the field. Each SDSS source is ``phot-ed`` with a range of apertures that
are multiples of the mean ``fwhm`` of SDSS stars in the field. Specifically,
``phot`` is done using ``1 - 7*fwhm`` in steps of ``0.5``. This function
calculates the difference in the instrumental magnitude in aperture 'n'
with aperture ``n-1``. The aperture at which this difference levels off is
where we determine what the aperture correction is. This is typically around
``4.5 to 5*fwhm``, but can vary depending on the data. This difference
between this leveling off point, and the magnitude measured using ``1*fwhm``
is the returned aperture correction. Sigma clipping is used to throw out
values that would throw off the measurement.
Parameters
----------
img : str
String containing name of the image currently in us
fhwm : float
average of median fwhm of SDSS sources in the field
inspect : boolean
if ``True`` each candidate aperture correction star will be
displayed. This gives you the chance to throw out stars that
have near neighbors or next to image artifacts.
Returns
-------
apcor : float
mean aperture correction of candidate starts remaining After
sigma clipping
apcor_std : float
standard deviation of aperture corrections of candidate starts
remaining After sigma clipping
apcor_sem : float
standard error on the mean of the aperture corrections of
candidate starts remaining After sigma clipping
"""
from pyraf import iraf
import matplotlib.pyplot as plt
from scipy import interpolate
from matplotlib.colors import LogNorm
# from astropy.visualization import *
from astropy.visualization.mpl_normalize import ImageNormalize, LogStretch
iraf.ptools(_doprint=0)
sdss_source_file = img.nofits()+'.match.sdssxy'
sdss_phot_file = img.nofits()+'.sdssphot'
sdss_MAG, sdss_MERR, sdss_SKY, sdss_SERR, sdss_RAPERT, sdss_XPOS, sdss_YPOS = np.loadtxt(img.nofits()+'.sdssphot',
usecols=(1,2,3,4,5,6,7),
dtype=float, unpack=True)
x,y,ra,dec,g,g_err,r,r_err = np.loadtxt(sdss_source_file,usecols=(0,1,2,3,
6,7,8,9),unpack=True)
peak,gfwhm = getfwhm_full_sdss(img)
#odi.plt.figure()
#odi.plt.hist(peak[np.where(g < 19)])
#odi.plt.figure()
#odi.plt.hist(gfwhm[np.where(g < 19)])
#odi.plt.show()
#plt.clf()
#plt.hist(peak[np.where(peak > 12000.0)])
#plt.show()
aps = []
for i in np.arange(1,7.5,0.5):
aps.append(fwhm*i)
#aps = np.ones(13)*5.0
aps_str = str('"'+repr(aps[0])+','+repr(aps[1])+','
+repr(aps[2])+','+repr(aps[3])+','
+repr(aps[4])+','+repr(aps[5])+','
+repr(aps[6])+','+repr(aps[7])+','
+repr(aps[8])+','+repr(aps[9])+','
+repr(aps[10])+','+repr(aps[11])+','
+repr(aps[12])+'"')
hdulist = odi.fits.open(img.f)
hdr1 = hdulist[0].header
data = hdulist[0].data
filter = hdr1['filter']
hdulist.close()
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread','rdnoise')
iraf.datapars.setParam('exposure',"exptime")
#iraf.datapars.setParam('itime',2700.0)
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
phot_tbl = img.nofits()+'.apcor'
if not os.path.isfile(phot_tbl):
print 'running phot over', aps_str
iraf.datapars.setParam('fwhmpsf',fwhm)
iraf.photpars.setParam('apertures',aps_str)
iraf.fitskypars.setParam('annulus',6.*float(fwhm))
iraf.apphot.phot(image=img, coords=sdss_source_file, output=img.nofits()+'.apcor.1')
with open(phot_tbl,'w+') as txdump_out :
iraf.ptools.txdump(textfiles=img.nofits()+'.apcor.1', fields="ID,RAPERT,XCEN,YCEN,FLUX,MAG,MERR", expr="yes", headers='no', Stdout=txdump_out)
txdump_out.close()
outputfile_clean = open(phot_tbl.replace('.apcor','_clean.apcor'),"w")
for line in open(phot_tbl,"r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF','999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.apcor','_clean.apcor'),phot_tbl)
peak_top1per = 49000.0
star_flux = {}
star_mag_diff = {}
star_mag_diff1x = {}
star_mag = {}
star_positions = {}
for i,line in enumerate(open(img.nofits()+'.apcor',"r")):
flux = [float(x) for x in line.split()[16:29]]
mag = [float(x) for x in line.split()[29:42]]
err = [float(x) for x in line.split()[42:55]]
position = [float(x) for x in line.split()[14:16]]
#print i,peak[i],gfwhm[i],g[i]
if (peak[i] > 2500.0 and peak[i] <= 55000.0 and
(np.abs(gfwhm[i] - np.median(gfwhm[np.where(gfwhm < 20.0)])) < np.std(gfwhm[np.where(gfwhm < 20.0)]))
and np.max(mag) != 999.0):
if inspect == True:
center = position
x1 = center[0]-75
x2 = center[0]+75
y1 = center[1]-75
y2 = center[1]+75
box = data[y1:y2,x1:x2]
plt.figure()
norm = ImageNormalize(stretch=LogStretch())
odi.plt.imshow(box,norm=norm)
max_count = np.max(box)
odi.plt.title('max counts ='+str(max_count))
plt.show()
star_check = raw_input('Use star for ap correction: (y/n) ')
if star_check == 'y':
star_flux[i] = flux
star_mag[i] = mag
star_positions[i] = position
else:
star_positions[i] = position
star_flux[i] = flux
star_mag[i] = mag
for key in star_mag:
diffs = []
diffs1x = []
for m in range(len(star_mag[key])-1):
diffs.append(star_mag[key][m+1] - star_mag[key][m])
diffs1x.append(star_mag[key][m] - star_mag[key][0])
#print star_mag[key][8],star_mag[key][0]
star_mag_diff[key] = diffs
star_mag_diff1x[key] = diffs1x
combine_mag_diffs = []
combine_mag_diffs1x = []
for key in star_mag_diff:
x = np.arange(1,7.0,0.5)
y = star_mag_diff[key]
z = star_mag_diff1x[key]
#plt.plot(x,y,'o')
#plt.show()
combine_mag_diffs.append(y)
combine_mag_diffs1x.append(z)
#tck = interpolate.splrep(x, y, s=0)
#xnew = np.arange(1,6,0.25)
#ynew = interpolate.splev(xnew,tck,der=1)
#print len(np.arange(1,6.5,0.5)),len(star_mag_diff[key])
#plt.plot(np.arange(1,6.5,0.5),star_mag_diff[key],'o')
#plt.plot(xnew,ynew,'-')
#plt.axhline(y=0)
#plt.show()
combine_mag_diffs = np.reshape(combine_mag_diffs,(len(star_mag_diff.keys()),len(x)))
combine_mag_diffs_med = []
combine_mag_diffs_std = []
combine_mag_diffs1x = np.reshape(combine_mag_diffs1x,(len(star_mag_diff1x.keys()),len(x)))
combine_mag_diffs1x_mean = []
combine_mag_diffs1x_med = []
combine_mag_diffs1x_std = []
combine_mag_diffs1x_sem = []
for j in range(len(x)):
if j !=0 :
star_test = combine_mag_diffs1x[:,j]
star_test = star_test[np.where(((star_test >= -0.5) & (star_test <= 0)))]
sig_test = np.std(combine_mag_diffs1x[:,j])
#print sig_test,len(star_test)
med_test = np.median(combine_mag_diffs1x[:,j])
keep = star_test[np.where(np.abs(star_test-med_test) < 0.01)]
#plt.hist(keep)
#plt.show()
combine_mag_diffs1x_mean.append(np.mean(keep))
combine_mag_diffs1x_med.append(np.median(keep))
combine_mag_diffs1x_std.append(np.std(keep))
combine_mag_diffs1x_sem.append(np.std(keep)/np.sqrt(len(keep)))
if j == 8:
print 'using ',len(keep), 'stars in ap correction'
else:
combine_mag_diffs1x_mean.append(np.mean(combine_mag_diffs1x[:,j]))
combine_mag_diffs1x_med.append(np.median(combine_mag_diffs1x[:,j]))
combine_mag_diffs1x_std.append(np.std(combine_mag_diffs1x[:,j]))
combine_mag_diffs1x_sem.append(np.std(combine_mag_diffs1x[:,j])/np.sqrt(len(combine_mag_diffs1x[:,j])))
combine_mag_diffs_med.append(np.median(combine_mag_diffs[:,j]))
combine_mag_diffs_std.append(np.std(combine_mag_diffs[:,j]))
tck = interpolate.splrep(x, combine_mag_diffs_med, s=0)
xnew = np.arange(1,7.0,0.25)
ynew = interpolate.splev(xnew,tck,der=0)
ynew_der = interpolate.splev(xnew,tck,der=1)
plt.figure(figsize=(14,7))
ax1 = plt.subplot(121)
ax2 = plt.subplot(122)
ax1.errorbar(x,combine_mag_diffs_med,yerr=combine_mag_diffs_std,fmt='o',label='Median mag. Diff.')
ax1.plot(xnew,ynew,'r-',label='Spline fit')
ax1.set_ylabel('Mag(n+1) - Mag(n)')
ax1.set_xlabel('n $ \cdot $ fwhm')
ax2.plot(xnew,ynew_der,'r-')
ax2.axhline(y=0)
ax2.set_ylabel('Value of Spline 1st Derivative')
ax2.set_xlabel('n $ \cdot $ fwhm')
ax1.legend(loc=4)
plt.tight_layout()
plt.show()
# print combine_mag_diffs1x_mean
# print combine_mag_diffs1x_std
# print combine_mag_diffs1x_sem
for i in range(len(x)):
plt.errorbar(x[i],combine_mag_diffs1x_mean[i],yerr=combine_mag_diffs1x_std[i],fmt='bo')
plt.ylim(-0.45,0.1)
plt.xlim(-0.1,7.5)
plt.xlabel('n fwhm')
plt.ylabel('ap correction')
plt.show()
#apcor = np.median(combine_mag_diffs1x_mean[5:10:1])
apcor = combine_mag_diffs1x_mean[8]
apcor_std = combine_mag_diffs1x_std[8]
apcor_sem = combine_mag_diffs1x_sem[8]
apcor_med = combine_mag_diffs1x_med[8]
print 'aperture corr. = {0:6.3f}'.format(apcor)
print 'aperture corr. med. = {0:6.3f}'.format(apcor_med)
print 'aperture corr. std = {0:6.3f}'.format(apcor_std)
print 'aperture corr. sem = {0:6.3f}'.format(apcor_sem)
return apcor, apcor_std, apcor_sem
def sdss_phot_full(img,fwhm,airmass):
"""
Run ``pyraf phot`` on SDSS sources in the field. ``phot`` is given the
following parameters ::
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread','rdnoise')
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
iraf.datapars.setParam('xairmass',float(airmass))
iraf.datapars.setParam('fwhmpsf',float(fwhm))
iraf.photpars.setParam('apertures',5.*float(fwhm)) # use a big aperture for this
iraf.fitskypars.setParam('annulus',6.*float(fwhm))
Parameters
----------
img : str
String containing name of the image currently in use
fwhm : float
A measure of the fwhm of stars in the stacked image
airmass : float
Airmass assigned to the stacked image. Should match the image in the
dither that was used as the reference scaling image.
"""
from pyraf import iraf
iraf.ptools(_doprint=0)
# first grab the header and hang on to it so we can use other values
hdulist = odi.fits.open(img.f)
hdr1 = hdulist[0].header
filter = hdr1['filter']
hdulist.close()
iraf.unlearn(iraf.phot,iraf.datapars,iraf.photpars,iraf.centerpars,iraf.fitskypars)
iraf.apphot.phot.setParam('interactive',"no")
iraf.apphot.phot.setParam('verify',"no")
iraf.datapars.setParam('datamax',50000.)
iraf.datapars.setParam('gain',"gain")
iraf.datapars.setParam('ccdread','rdnoise')
iraf.datapars.setParam('exposure',"exptime")
iraf.datapars.setParam('filter',"filter")
iraf.datapars.setParam('obstime',"time-obs")
iraf.datapars.setParam('sigma',"INDEF")
iraf.photpars.setParam('zmag',0.)
iraf.centerpars.setParam('cbox',9.)
iraf.centerpars.setParam('maxshift',3.)
iraf.fitskypars.setParam('salgorithm',"median")
iraf.fitskypars.setParam('dannulus',10.)
if not os.path.isfile(img.nofits()+'.sdssphot'): # only do this once
print 'phot-ing the sdss sources in ', filter
iraf.datapars.setParam('xairmass',float(airmass))
iraf.datapars.setParam('fwhmpsf',float(fwhm))
iraf.photpars.setParam('apertures',5.*float(fwhm)) # use a big aperture for this
iraf.fitskypars.setParam('annulus',6.*float(fwhm))
iraf.apphot.phot(image=img, coords=img.nofits()+'.match.sdssxy', output=img.nofits()+'.phot.1')
phot_tbl = img.nofits()+'.sdssphot'
with open(phot_tbl,'w+') as txdump_out :
iraf.ptools.txdump(textfiles=img.nofits()+'.phot.1', fields="id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,image",expr='yes', headers='no', Stdout=txdump_out)
outputfile_clean = open(phot_tbl.replace('.sdssphot','_clean.sdssphot'),"w")
for line in open(phot_tbl,"r"):
if not 'INDEF' in line:
outputfile_clean.write(line)
if 'INDEF' in line:
outputfile_clean.write(line.replace('INDEF','999'))
outputfile_clean.close()
os.rename(phot_tbl.replace('.sdssphot','_clean.sdssphot'),phot_tbl)
