def detect_stars(f,params):
print 'Detecting stars in',f.name
print 'Current directory is', os.getcwd()
fp = params.loc_output+os.path.sep
fn = f.fullname
iraf.digiphot()
iraf.daophot()
print 'FWHM = ',f.fw
nstars = 0
thresh = 100
while (nstars < 2*params.nstamps) and (thresh > 1.5):
print 'thresh = ',thresh
for d in ['temp.stars','temp.phot']:
if os.path.exists(fp+d):
os.system('/bin/rm '+fp+d)
iraf.daofind(image=fn,output=fp+'temp.stars',interactive='no',verify='no',
threshold=thresh,sigma=30,fwhmpsf=f.fw,
datamin=params.pixel_min,datamax=params.pixel_max,
epadu=params.gain,readnoise=params.readnoise,
noise='poisson')
iraf.phot(image=fn,output=fp+'temp.phot',coords=fp+'temp.stars',interactive='no',
verify='no',
sigma=30,fwhmpsf=f.fw,datamin=params.pixel_min,
datamax=params.pixel_max,epadu=params.gain,
readnoise=params.readnoise,noise='poisson',Stdout='/dev/null')
nstars = 0
if os.path.exists(fp+'temp.phot'):
iraf.psort(infiles=fp+'temp.phot',field='MAG')
iraf.prenumber(infile=fp+'temp.phot')
s = iraf.pdump(infiles=fp+'temp.phot',Stdout=1,fields='ID,XCENTER,YCENTER,MAG',
expr='yes')
stars = np.zeros([len(s),3])
i = 0
for line in s:
mag = line.split()[3]
if not(mag == 'INDEF'):
stars[i,:] = np.array(map(float,line.split()[1:4]))
i += 1
nstars = i
thresh = thresh*0.5
if nstars == 0:
print 'Error: could not detect stars in',fn
return None
stars = stars[:i,:].copy()
sys.old_stdout = sys.stdout
return stars
def psf_photometry_pairitel(imagebi, satmag, photfilesuffix,psfstarfile='',thresh=6., psfcleaningradius=10., ds9=False):
'''This method performs psf photometry on a single fits extension
It first sets some global daophot parameters, selects psf stars, computes the psf, cleans
the psf stars from close neighbours and recomputes te psf and then fits all sources in the field.
Existing aperture photometry (.coo and .mag files) in the directory is a PREREQUISITE for this routine.
keyword: ds9=False: If true the method writes a files with X Y coords of all succesfully fitted sources in the current WCS
'''
# fit the psf (using 2 rounds, i.e. initial psf model + refining the model by subtracting nearby stars in the wings of the psf stars.)
psf_star_fitting_2runs(imagebi, psfstarfile,photfilesuffix,satmag, psfcleaningradius)
# now extract all stars using the second-round psf model.
iraf.datapars.datamin="INDEF"
iraf.daophot.allstar(imagebi,photfile=imagebi+photfilesuffix,psfimage=get_last_iraf(imagebi+'.psf',suffix='fits'),allstarfile='default',rejfile='default',subimage='default',verbose=False)
xycenter_to_ds9reg(get_last_iraf(imagebi+'.als'), 'stars_1.reg')
# take the sub.image (produced as a by-product in the previous step) where all the found sources are subtracted, and find all remaining sources which were so far hidden in the glare of brighter stars.
# find the sources in the sub.image, using somewhat higher significance threshold so that we don't pick up residuals from the psf subtraction:
original_threshold=iraf.findpars.threshold
iraf.datapars.datamin="INDEF"
iraf.findpars.threshold=thresh
iraf.daophot.daofind(get_last_iraf(imagebi+'.sub',suffix='fits'),'default', verbose=False)
iraf.findpars.threshold=original_threshold
# get preliminary magnitudes for those sources, using the original image:
iraf.daophot.phot(imagebi, coords=get_last_iraf(imagebi+'.sub.2.fits.coo'), output=imagebi+'.secondrun.mag.1', verbose=False, verify=False, interactive=False)
# now merge the preliminary new sources with the sourcelist from the first round:
iraf.pfmerge(inphotfiles=get_last_iraf(imagebi+'.als')+','+imagebi+'.secondrun.mag.1', outphotfile=get_next_iraf(imagebi+'.als'))
# and renumber the sources so that they have unique IDs:
iraf.prenumber(get_last_iraf(imagebi+'.als'))
# Now extract all sources, old and new, with PSF fitting. This will shift the sources around a bit and also throw out sources that are not significantly detected.
iraf.daophot.allstar(imagebi,get_last_iraf(imagebi+'.als'),get_last_iraf(imagebi+'.psf',suffix='fits'),get_next_iraf(imagebi+'.als'),'default','default',verbose=False)
xycenter_to_ds9reg(get_last_iraf(imagebi+'.als'), 'stars_2.reg')
def alignImages(imageName, imageName_Ha):
#Read the fwhm and seeing from the image file
imageHeader = fits.open(imageName + ".fits")[0]
fwhm = imageHeader.header['SEEING']
annul = 5.0 * fwhm
aper = 3.0 * fwhm
sigma = imageHeader.header['SKYSIGMA']
iraf.daophot(_doprint=0)
#Do 'daofind' on the image to locate the stars
print("1. Find stars using 'daofind'")
#Configure 'datapars', 'findpars', and 'daofind'
iraf.datapars.fwhmpsf = fwhm
iraf.datapars.sigma = sigma
iraf.datapars.datamin = -10
iraf.datapars.ccdread = "RDNOISE"
iraf.datapars.gain = "GAIN"
iraf.datapars.exposure = "EXPTIME"
iraf.datapars.airmass = "AIRMASS"
iraf.datapars.filter = "FILTER"
iraf.datapars.obstime = "TIME-OBS"
iraf.findpars.threshold = 20 * sigma
iraf.findpars.sharplo = 0.2
iraf.findpars.sharphi = 1.0
iraf.findpars.roundlo = -1.0
iraf.findpars.roundhi = 1.0
iraf.daofind.verify = 'no'
iraf.daofind.verbose = 'no'
#Delete exisiting coordinate,output files of 'phot',file containg data of 'good' stars, old images
for f in ("coord", "mag", "psel", "R_final.fits", "Ha_final.fits"):
silentDelete(f)
iraf.daofind(imageName, 'coord')
print("File containing the coordinates of the stars is coord")
print(" ")
#Configure 'centerpars', 'fitskypars','photpars'
iraf.datapars.datamax = 150000
iraf.centerpars.calgorithm = "centroid"
iraf.centerpars.cbox = 16
iraf.centerpars.maxshift = 3
iraf.fitskypars.salgorithm = "mode"
iraf.fitskypars.annulus = annul
iraf.fitskypars.dannulus = 10
iraf.photpars.apertures = aper
iraf.phot.verify = 'no'
iraf.phot.verbose = 'no'
print("2. Obtain data of stars using 'phot'")
#Call 'phot' to get the data of the stars
iraf.phot(imageName, 'coord', 'mag')
#sort in order of increasing magnitude of stars
iraf.psort('mag', "mag")
boundsig = sigma + 2
boexpr = "CIER==0 && PIER==0 && STDEV <=" + str(boundsig)
print(
"File containing the data of the stars in order of decreasing brightness is mag"
)
print(" ")
print("3. Select stars with low error, no bad pixels")
#Select stars that have no centering error, skyerror <sig+2 and no bad pixels
iraf.pselect("mag", "psel", boexpr)
print(
"File containing stars with low sky error,low centering error is psel")
print(" ")
#Renumber the ID number of the stars in order of increasing magnitude
iraf.prenumber("psel")
#Delete existing files
for f in ("pdump.file", "stars25", 'alR.fits', 'rIn.fits', 'haIn.fits'):
silentDelete(f)
print("4. Select the 25 brightest stars")
iraf.pselect("psel", "stars25", "ID <=25")
print("File containing the brightest 25 'good' stars is stars25")
print(" ")
#Pick out only the required data of stars from the .25 file
sys.stdout = open("pdump.file", "w")
iraf.pdump("stars25", "xcenter,ycenter,flux", "yes")
sys.stdout = sys.__stdout__
print("The coordinates and flux are stored in pdump.file")
#Align images
iraf.imcopy(imageName, 'rIn')
iraf.imcopy(imageName_Ha, 'haIn')
print("Aligning images")
#iraf.imalign.verbose='no'
iraf.imalign("rIn,haIn", "rIn", "pdump.file", "R_final,Ha_final")
def compute_psf_image(params,g,psf_deg=1,psf_rad=8,
star_file='phot.mags',psf_image='psf.fits',edge_dist=5):
iraf.digiphot()
iraf.daophot()
fp = params.loc_output+os.path.sep
f_im = g.image*g.mask
f = fp+'temp.ref.fits'
write_image(f_im,f)
g.fw = np.max([1.5,g.fw])
g.fw = np.min([0.5*params.psf_max_radius,g.fw])
logfile = fp+'psf.log'
fd = fits.getdata(f)
xmax = fd.shape[0] - edge_dist
ymax = fd.shape[1] - edge_dist
for d in ['temp.stars','temp.phot','temp.phot1','temp.phot2','temp.pst',
'temp.opst','temp.opst2',
'temp.psf.fits','temp.psf1.fits','temp.psf2.fits','temp.psg',
'temp.psg2','temp.psg3','temp.psg5','temp.rej','temp.rej2',
'temp.sub.fits','temp.sub1.fits',
'temp.sub2.fits','temp.opst1','temp.opst3','temp.rej3',
'temp.nst','temp.stars1','ref.mags',psf_image,'temp.als',
'temp.als2']:
if os.path.exists(fp+d):
os.remove(fp+d)
# locate stars
iraf.daofind(image=f,output=fp+'temp.stars',interactive='no',verify='no',
threshold=3,sigma=params.star_detect_sigma,fwhmpsf=g.fw,
datamin=1,datamax=params.pixel_max,
epadu=params.gain,readnoise=params.readnoise,
noise='poisson')
if params.star_file:
als_recenter = 'no'
all_template_stars = np.genfromtxt(params.star_file)
all_new_stars = np.genfromtxt(fp+'temp.stars')
if all_new_stars.shape[0] > params.star_file_number_match:
new_stars = all_new_stars[all_new_stars[:,2].argsort()][:params.star_file_number_match]
else:
new_stars = all_new_stars
if all_template_stars.shape[0] > params.star_file_number_match:
template_stars = all_template_stars[all_template_stars[:,3].argsort()][:params.star_file_number_match]
else:
template_stars = all_template_stars
tx, ty = compute_xy_shift(new_stars,template_stars[:,1:3],0.5,
degree=params.star_file_transform_degree)
if params.star_file_has_magnitudes:
star_positions = all_template_stars[:,1:4]
xx = (star_positions[:,0]-np.mean(new_stars[:,0]))/np.mean(new_stars[:,0])
yy = (star_positions[:,1]-np.mean(new_stars[:,1]))/np.mean(new_stars[:,1])
for m in range(params.star_file_transform_degree+1):
for n in range(params.star_file_transform_degree+1-m):
star_positions[:,0] += tx[m,n]* xx**m * yy**n
star_positions[:,1] += ty[m,n]* xx**m * yy**n
np.savetxt(fp+'temp.stars.1',star_positions,fmt='%10.3f %10.3f %10.3f')
else:
star_positions = all_template_stars[:,1:3]
xx = (star_positions[:,0]-np.mean(new_stars[:,0]))/np.mean(new_stars[:,0])
yy = (star_positions[:,1]-np.mean(new_stars[:,1]))/np.mean(new_stars[:,1])
for m in range(params.star_file_transform_degree+1):
for n in range(params.star_file_transform_degree+1-m):
star_positions[:,0] += tx[m,n]* xx**m * yy**n
star_positions[:,1] += ty[m,n]* xx**m * yy**n
np.savetxt(fp+'temp.stars.1',star_positions,fmt='%10.3f %10.3f')
all_template_stars[:,1] = star_positions[:,0]
all_template_stars[:,2] = star_positions[:,1]
else:
als_recenter = 'yes'
star_positions = np.genfromtxt(fp+'temp.stars')
np.savetxt(fp+'temp.stars.1',star_positions[:,:2],fmt='%10.3f %10.3f')
iraf.phot(image=f,output=fp+'temp.phot',coords=fp+'temp.stars.1',interactive='no',
verify='no',
sigma=params.star_detect_sigma,fwhmpsf=g.fw,apertures=g.fw,
datamin=1,
datamax=2*params.pixel_max,epadu=params.gain,annulus=3*g.fw,
dannulus=3.0,
readnoise=params.readnoise,noise='poisson')
print 'fw = ',g.fw
#fw = np.max([4.0,fw])
#print 'fw = ',fw
# select PSF stars
iraf.pstselect(image=f,photfile=fp+'temp.phot',pstfile=fp+'temp.pst',maxnpsf=40,
interactive='no',verify='no',datamin=1,fitrad=2.0,
datamax=params.pixel_max,epadu=params.gain,psfrad=np.max([3.0,g.fw]),
readnoise=params.readnoise,noise='poisson')
if params.star_file and params.star_file_has_magnitudes:
# We don't need to do the photometry - only make the PSF
# Initial PSF estimate to generate PSF groups
#psfrad=3*np.max([g.fw,1.8])
iraf.psf(image=f,photfile=fp+'temp.phot',pstfile=fp+'temp.pst',psfimage=fp+'temp.psf',
function=params.psf_profile_type,opstfile=fp+'temp.opst',
groupfile=fp+'temp.psg',
interactive='no',
verify='no',varorder=0 ,psfrad=2*np.max([g.fw,1.8]),
datamin=-10000,datamax=0.95*params.pixel_max,
scale=1.0)
# construct a file of the psf neighbour stars
slist = []
psf_stars = np.loadtxt(fp+'temp.opst',usecols=(0,1,2))
for star in range(psf_stars.shape[0]):
xp = psf_stars[star,1]
yp = psf_stars[star,2]
xmin = np.max([np.int(xp-10*g.fw),0])
xmax = np.min([np.int(xp+10*g.fw),f_im.shape[0]])
ymin = np.max([np.int(yp-10*g.fw),0])
ymax = np.min([np.int(yp+10*g.fw),f_im.shape[1]])
p = star_positions[np.logical_and(np.logical_and(star_positions[:,0]>xmin,
star_positions[:,0]<xmax),
np.logical_and(star_positions[:,1]>ymin,
star_positions[:,1]<ymax))]
slist.append(p)
group_stars = np.concatenate(slist)
np.savetxt(fp+'temp.nst',group_stars,fmt='%10.3f %10.3f %10.3f')
# subtract PSF star neighbours
iraf.substar(image=f,photfile=fp+'temp.nst',psfimage=fp+'temp.psf',
exfile=fp+'temp.opst',fitrad=2.0,
subimage=fp+'temp.sub1',verify='no',datamin=1,
datamax=params.pixel_max,epadu=params.gain,
readnoise=params.readnoise,noise='poisson')
# final PSF
iraf.psf(image=fp+'temp.sub1',photfile=fp+'temp.phot',pstfile=fp+'temp.opst',
psfimage=psf_image,psfrad=2*g.fw,
function=params.psf_profile_type,opstfile=fp+'temp.opst2',
groupfile=fp+'temp.psg2',
interactive='no',
verify='no',varorder=0,
datamin=1,datamax=0.95*params.pixel_max,
scale=1.0)
np.savetxt(fp+'ref.mags',all_template_stars,fmt='%7d %10.3f %10.3f %10.3f')
stars = all_template_stars
else:
# initial PSF estimate
iraf.psf(image=f,photfile=fp+'temp.phot',pstfile=fp+'temp.pst',psfimage=fp+'temp.psf',
function=params.psf_profile_type,opstfile=fp+'temp.opst',
groupfile=fp+'temp.psg1',
interactive='no',
verify='no',varorder=0 ,psfrad=2*g.fw,
datamin=1,datamax=0.95*params.pixel_max,
scale=1.0)
# separation distance of near neighbours
separation = np.max([rewrite_psg(fp+'temp.psg1',fp+'temp.psg2'),3])
print 'separation = ',separation
# subtract all stars using truncated PSF
iraf.allstar(image=f,photfile=fp+'temp.phot',psfimage=fp+'temp.psf',
allstarfile=fp+'temp.als',rejfile='',
subimage=fp+'temp.sub',verify='no',psfrad=2*g.fw,fitrad=2.0,
recenter='yes',groupsky='yes',fitsky='yes',sannulus=7,wsannulus=10,
datamin=1,datamax=params.pixel_max,
epadu=params.gain,readnoise=params.readnoise,
noise='poisson')
if params.star_file:
os.system('cp '+fp+'temp.phot '+fp+'temp.phot2')
else:
# locate new stars
iraf.daofind(image=fp+'temp.sub',output=fp+'temp.stars1',interactive='no',verify='no',
threshold=3,sigma=params.star_detect_sigma,fwhmpsf=2*g.fw,
datamin=1,datamax=params.pixel_max,
epadu=params.gain,readnoise=params.readnoise,
noise='poisson')
# magnitudes for new stars
iraf.phot(image=fp+'temp.sub',output=fp+'temp.phot1',coords=fp+'temp.stars1',
interactive='no',
verify='no',sigma=params.star_detect_sigma,
fwhmpsf=g.fw,datamin=1,
datamax=params.pixel_max,epadu=params.gain,
readnoise=params.readnoise,noise='poisson')
# join star lists together
iraf.pconcat(infiles=fp+'temp.phot,'+fp+'temp.phot1',outfile=fp+'temp.phot2')
# new PSF estimate to generate PSF groups
iraf.psf(image=f,photfile=fp+'temp.phot2',pstfile=fp+'temp.pst',psfimage=fp+'temp.psf2',
function=params.psf_profile_type,opstfile=fp+'temp.opst2',
groupfile=fp+'temp.psg3',
interactive='no',
verify='no',varorder=0 ,psfrad=2*g.fw,
datamin=-10000,datamax=0.95*params.pixel_max,
scale=1.0)
# magnitudes for PSF group stars
iraf.nstar(image=f,groupfile=fp+'temp.psg3',psfimage=fp+'temp.psf2',
nstarfile=fp+'temp.nst',
rejfile='',verify='no',psfrad=2*g.fw,fitrad=2.0,
recenter='no',
groupsky='yes',fitsky='yes',sannulus=7,wsannulus=10,
datamin=1,datamax=params.pixel_max,
epadu=params.gain,readnoise=params.readnoise,noise='poisson')
# subtract PSF star neighbours
iraf.substar(image=f,photfile=fp+'temp.nst',psfimage=fp+'temp.psf2',
exfile=fp+'temp.opst2',fitrad=2.0,
subimage=fp+'temp.sub1',verify='no',datamin=1,
datamax=params.pixel_max,epadu=params.gain,
readnoise=params.readnoise,noise='poisson')
# final PSF
iraf.psf(image=fp+'temp.sub1',photfile=fp+'temp.phot2',
pstfile=fp+'temp.opst2',
psfimage=psf_image,psfrad=2*g.fw,
function=params.psf_profile_type,opstfile=fp+'temp.opst3',
groupfile=fp+'temp.psg5',
interactive='no',
verify='no',varorder=0,
datamin=1,datamax=0.95*params.pixel_max,
scale=1.0)
# final photometry
iraf.allstar(image=g.fullname,photfile=fp+'temp.phot2',psfimage=psf_image,
allstarfile=fp+'temp.als2',rejfile='',
subimage=fp+'temp.sub2',verify='no',psfrad=2*g.fw,
recenter=als_recenter,groupsky='yes',fitsky='yes',sannulus=7,
wsannulus=10,fitrad=2.0,
datamin=params.pixel_min,datamax=params.pixel_max,
epadu=params.gain,readnoise=params.readnoise,
noise='poisson')
psfmag = 10.0
for line in open(fp+'temp.als2','r'):
sline = line.split()
if sline[1] == 'PSFMAG':
psfmag = float(sline[3])
break
if params.star_file:
iraf.psort(infiles=fp+'temp.als2',field='ID')
os.system('cp '+fp+'temp.als2 '+fp+'temp.als3')
else:
selection = 'XCE >= '+str(edge_dist)+' && XCE <= '+str(xmax)+' && YCE >= '+str(edge_dist)+' && YCE <= '+str(ymax)+' && MAG != INDEF'
iraf.pselect(infiles=fp+'temp.als2',outfiles=fp+'temp.als3',expr=selection)
iraf.psort(infiles=fp+'temp.als3',field='MAG')
iraf.prenumber(infile=fp+'temp.als3')
s = iraf.pdump(infiles=fp+'temp.als3',Stdout=1,
fields='ID,XCENTER,YCENTER,MAG,MERR,MSKY,SHARPNESS,CHI',expr='yes')
sf = [k.replace('INDEF','22.00') for k in s]
stars = np.zeros([len(sf),5])
for i, line in enumerate(sf):
stars[i,:] = np.array(map(float,sf[i].split()[1:6]))
s = iraf.pdump(infiles=fp+'temp.als3',Stdout=1,
fields='ID,XCENTER,YCENTER,MAG,MERR,SHARPNESS,CHI,MSKY',expr='yes')
sf = [k.replace('INDEF','22.00') for k in s]
with open(fp+'ref.mags','w') as fid:
for s in sf:
fid.write(s+'\n')
return stars
tfe = time.time()
times[runnm + '_psf'] = tfe - tfs
iraf.seepsf(psfimage=flnm + '.psf.fits',
image=flnm + '.image_of_psf.fits')
if i == 0:
shutil.copy(runnm + '.mag',
runnm + '.tot.mag') # formatting reasons only
else:
print "========================================="
print "...merging phot lists"
print "========================================="
iraf.pfmerge(inphotfi=str(flnm + '.sub.' + str(i - 1) + '.als' + ',' +
runnm + '.mag'),
outphotf=runnm + '.tot.mag')
iraf.prenumber(runnm + '.tot.mag')
print "========================================="
print "...running allstar for", runnm + '.fits'
print "========================================="
iraf.daopars.setParam('recenter', 'yes')
tas = time.time()
iraf.allstar(image=initimg,
photfile=runnm + '.tot.mag',
psfimage=flnm + '.psf.fits',
allstarf=runnm + '.als',
rejfile=runnm + '.arj',
subimage=flnm + '.sub.' + str(i + 1) + '.fits',
cache='no',
verify='no') # ALLSTAR on original sub.0
tae = time.time()
def alignImages(imageName,imageName_Ha):
#Read the fwhm and seeing from the image file
imageHeader = fits.open(imageName+".fits")[0]
fwhm = imageHeader.header['SEEING']
annul = 5.0 * fwhm
aper=3.0 * fwhm
sigma = imageHeader.header['SKYSIGMA']
iraf.daophot(_doprint=0)
#Do 'daofind' on the image to locate the stars
print("1. Find stars using 'daofind'")
#Configure 'datapars', 'findpars', and 'daofind'
iraf.datapars.fwhmpsf=fwhm
iraf.datapars.sigma=sigma
iraf.datapars.datamin=-10
iraf.datapars.ccdread="RDNOISE"
iraf.datapars.gain="GAIN"
iraf.datapars.exposure="EXPTIME"
iraf.datapars.airmass="AIRMASS"
iraf.datapars.filter="FILTER"
iraf.datapars.obstime="TIME-OBS"
iraf.findpars.threshold=20*sigma
iraf.findpars.sharplo=0.2
iraf.findpars.sharphi=1.0
iraf.findpars.roundlo=-1.0
iraf.findpars.roundhi=1.0
iraf.daofind.verify='no'
iraf.daofind.verbose='no'
#Delete exisiting coordinate,output files of 'phot',file containg data of 'good' stars, old images
for f in("coord","mag","psel","R_final.fits","Ha_final.fits"):
silentDelete(f)
iraf.daofind(imageName,'coord')
print("File containing the coordinates of the stars is coord")
print(" ")
#Configure 'centerpars', 'fitskypars','photpars'
iraf.datapars.datamax=150000
iraf.centerpars.calgorithm="centroid"
iraf.centerpars.cbox=16
iraf.centerpars.maxshift=3
iraf.fitskypars.salgorithm="mode"
iraf.fitskypars.annulus=annul
iraf.fitskypars.dannulus=10
iraf.photpars.apertures=aper
iraf.phot.verify='no'
iraf.phot.verbose='no'
print("2. Obtain data of stars using 'phot'")
#Call 'phot' to get the data of the stars
iraf.phot (imageName,'coord','mag')
#sort in order of increasing magnitude of stars
iraf.psort('mag',"mag")
boundsig=sigma+2
boexpr="CIER==0 && PIER==0 && STDEV <="+str(boundsig)
print("File containing the data of the stars in order of decreasing brightness is mag")
print (" ")
print("3. Select stars with low error, no bad pixels")
#Select stars that have no centering error, skyerror <sig+2 and no bad pixels
iraf.pselect ("mag" ,"psel" ,boexpr)
print("File containing stars with low sky error,low centering error is psel")
print(" ")
#Renumber the ID number of the stars in order of increasing magnitude
iraf.prenumber ("psel")
#Delete existing files
for f in ("pdump.file","stars25",'alR.fits','rIn.fits','haIn.fits'):
silentDelete(f)
print("4. Select the 25 brightest stars")
iraf.pselect ("psel","stars25", "ID <=25")
print("File containing the brightest 25 'good' stars is stars25")
print(" ")
#Pick out only the required data of stars from the .25 file
sys.stdout=open("pdump.file","w")
iraf.pdump ("stars25","xcenter,ycenter,flux","yes")
sys.stdout = sys.__stdout__
print("The coordinates and flux are stored in pdump.file")
#Align images
iraf.imcopy(imageName,'rIn')
iraf.imcopy(imageName_Ha,'haIn')
print("Aligning images")
#iraf.imalign.verbose='no'
iraf.imalign("rIn,haIn", "rIn","pdump.file","R_final,Ha_final")