def saltgain(images,
outimages,
outpref,
gaindb=None,
usedb=False,
mult=True,
clobber=True,
logfile='salt.log',
verbose=True):
#start logging
with logging(logfile, debug) as log:
# Check the input images
infiles = saltio.argunpack('Input', images)
# create list of output files
outfiles = saltio.listparse('Outfile', outimages, outpref, infiles, '')
#verify that the input and output lists are the same length
saltio.comparelists(infiles, outfiles, 'Input', 'output')
# read in the database file if usedb is true
if usedb:
gaindb = gaindb.strip()
dblist = saltio.readgaindb(gaindb)
else:
dblist = []
for img, oimg in zip(infiles, outfiles):
#open the fits file
struct = saltio.openfits(img)
# identify instrument
instrume, keyprep, keygain, keybias, keyxtalk, keyslot = saltkey.instrumid(
struct)
# has file been prepared already?
if saltkey.found(keygain, struct[0]):
message = 'SALTGAIN: %s has already been gain-corrected' % img
raise SaltError(message)
# gain correct the data
struct = gain(struct,
mult=mult,
usedb=usedb,
dblist=dblist,
log=log,
verbose=verbose)
# housekeeping keywords
fname, hist = history(level=1,
wrap=False,
exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0], keygain,
'Images have been gain corrected', hist)
# write FITS file
saltio.writefits(struct, oimg, clobber=clobber)
saltio.closefits(struct)
def saltprepare(images,outimages,outpref,createvar=False, badpixelimage=None, clobber=True,logfile='salt.log',verbose=True):
with logging(logfile,debug) as log:
# Check the input images
infiles = saltio.argunpack ('Input',images)
# create list of output files
outfiles=saltio.listparse('Outfile', outimages, outpref,infiles,'')
#verify that the input and output lists are the same length
saltio.comparelists(infiles,outfiles,'Input','output')
# open the badpixel image
if saltio.checkfornone(badpixelimage) is None:
badpixelstruct=None
else:
try:
badpixelstruct = saltio.openfits(badpixelimage)
except saltio.SaltIOError,e:
msg='badpixel image must be specificied\n %s' % e
raise SaltError(msg)
# open each raw image file
for img, oimg, in zip(infiles, outfiles):
#open the fits file
struct=saltio.openfits(img)
#if createvar, throw a warning if it is using slotmode
if saltkey.fastmode(saltkey.get('DETMODE', struct[0])) and createvar:
msg='Creating variance frames for slotmode data in %s' % img
log.warning(msg)
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot = saltkey.instrumid(struct)
# has file been prepared already?
try:
key = struct[0].header[keyprep]
message = 'ERROR -- SALTPREPARE: File ' + infile
message += ' has already been prepared'
raise SaltError(message)
except:
pass
# prepare file
struct=prepare(struct,createvar=createvar, badpixelstruct=badpixelstruct)
# housekeeping keywords
fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0],keyprep, 'File prepared for IRAF', hist)
# write FITS file
saltio.writefits(struct,oimg, clobber=clobber)
saltio.closefits(struct)
message = 'SALTPREPARE -- %s => %s' % (img, oimg)
log.message(message, with_header=False)
def saltprepare(images,outimages,outpref,createvar=False, badpixelimage=None, clobber=True,logfile='salt.log',verbose=True):
with logging(logfile,debug) as log:
# Check the input images
infiles = saltio.argunpack ('Input',images)
# create list of output files
outfiles=saltio.listparse('Outfile', outimages, outpref,infiles,'')
#verify that the input and output lists are the same length
saltio.comparelists(infiles,outfiles,'Input','output')
# open the badpixel image
if saltio.checkfornone(badpixelimage) is None:
badpixelstruct=None
else:
try:
badpixelstruct = saltio.openfits(badpixelimage)
except saltio.SaltIOError,e:
msg='badpixel image must be specificied\n %s' % e
raise SaltError(msg)
# open each raw image file
for img, oimg, in zip(infiles, outfiles):
#open the fits file
struct=saltio.openfits(img)
#if createvar, throw a warning if it is using slotmode
if saltkey.fastmode(saltkey.get('DETMODE', struct[0])) and createvar:
msg='Creating variance frames for slotmode data in %s' % img
log.warning(msg)
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot = saltkey.instrumid(struct)
# has file been prepared already?
try:
key = struct[0].header[keyprep]
message = 'ERROR -- SALTPREPARE: File ' + infile
message += ' has already been prepared'
raise SaltError(message)
except:
pass
# prepare file
struct=prepare(struct,createvar=createvar, badpixelstruct=badpixelstruct)
# housekeeping keywords
fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0],keyprep, 'File prepared for IRAF', hist)
# write FITS file
saltio.writefits(struct,oimg, clobber=clobber)
saltio.closefits(struct)
message = 'SALTPREPARE -- %s => %s' % (img, oimg)
log.message(message, with_header=False)
def saltxtalk(images,outimages,outpref,xtalkfile=None, usedb=False,
clobber=True, logfile='salt.log',verbose=True):
#start logging
with logging(logfile,debug) as log:
# Check the input images
infiles = saltio.argunpack ('Input',images)
# create list of output files
outfiles=saltio.listparse('Outfile', outimages, outpref,infiles,'')
# are input and output lists the same length?
saltio.comparelists(infiles,outfiles,'Input','output')
# does crosstalk coefficient data exist
if usedb:
xtalkfile = xtalkfile.strip()
xdict = saltio.readxtalkcoeff(xtalkfile)
else:
xdict=None
for img, oimg in zip(infiles, outfiles):
#open the fits file
struct=saltio.openfits(img)
#find the best xcoeff for the image if using the db
if usedb:
obsdate=saltkey.get('DATE-OBS', struct[0])
obsdate=int('%s%s%s' % (obsdate[0:4],obsdate[5:7], obsdate[8:]))
xkey=np.array(xdict.keys())
date=xkey[abs(xkey-obsdate).argmin()]
xcoeff=xdict[date]
else:
xcoeff=[]
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot = saltkey.instrumid(struct)
# has file been prepared already?
if saltkey.found(keyxtalk, struct[0]):
message='%s has already been xtalk corrected' % img
raise SaltError(message)
#apply the cross-talk correction
struct = xtalk(struct, xcoeff, log=log, verbose=verbose)
# housekeeping keywords
fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0], 'SXTALK', 'Images have been xtalk corrected', hist)
# write FITS file
saltio.writefits(struct,oimg, clobber=clobber)
saltio.closefits(struct)
def saltslot(images,
outimages,
outpref,
gaindb='',
xtalkfile='',
usedb=False,
clobber=False,
logfile='salt.log',
verbose=True):
#start logging
with logging(logfile, debug) as log:
# Check the input images
infiles = saltio.argunpack('Input', images)
# create list of output files
outfiles = saltio.listparse('Outfile', outimages, outpref, infiles, '')
# are input and output lists the same length?
saltio.comparelists(infiles, outfiles, 'Input', 'output')
# does crosstalk coefficient data exist
if usedb:
dblist = saltio.readgaindb(gaindb)
xtalkfile = xtalkfile.strip()
xdict = saltio.readxtalkcoeff(xtalkfile)
else:
dblist = []
xdict = None
for img, oimg in zip(infiles, outfiles):
#open the fits file
struct = saltio.openfits(img)
# identify instrument
instrume, keyprep, keygain, keybias, keyxtalk, keyslot = saltkey.instrumid(
struct)
# has file been prepared already?
if saltkey.found(keygain, struct[0]):
message = '%s has already been reduced' % img
raise SaltError(message)
# housekeeping keywords
fname, hist = history(level=1,
wrap=False,
exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0], keyslot,
'Images have been slotmode reduced', hist)
# write FITS file
saltio.writefits(struct, oimg, clobber=clobber)
saltio.closefits(struct)
def saltgain(images,outimages, outpref, gaindb=None,usedb=False, mult=True,
clobber=True, logfile='salt.log',verbose=True):
#start logging
with logging(logfile,debug) as log:
# Check the input images
infiles = saltio.argunpack ('Input',images)
# create list of output files
outfiles=saltio.listparse('Outfile', outimages, outpref,infiles,'')
#verify that the input and output lists are the same length
saltio.comparelists(infiles,outfiles,'Input','output')
# read in the database file if usedb is true
if usedb:
gaindb = gaindb.strip()
dblist= saltio.readgaindb(gaindb)
else:
dblist=[]
for img, oimg in zip(infiles, outfiles):
#open the fits file
struct=saltio.openfits(img)
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot = saltkey.instrumid(struct)
# has file been prepared already?
if saltkey.found(keygain, struct[0]):
message='SALTGAIN: %s has already been gain-corrected' % img
raise SaltError(message)
# gain correct the data
struct = gain(struct,mult=mult, usedb=usedb, dblist=dblist, log=log, verbose=verbose)
# housekeeping keywords
fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0],keygain, 'Images have been gain corrected', hist)
# write FITS file
saltio.writefits(struct,oimg, clobber=clobber)
saltio.closefits(struct)
def saltslot(images,outimages,outpref,gaindb='',xtalkfile='',usedb=False, clobber=False,logfile='salt.log',verbose=True):
#start logging
with logging(logfile,debug) as log:
# Check the input images
infiles = saltio.argunpack ('Input',images)
# create list of output files
outfiles=saltio.listparse('Outfile', outimages, outpref,infiles,'')
# are input and output lists the same length?
saltio.comparelists(infiles,outfiles,'Input','output')
# does crosstalk coefficient data exist
if usedb:
dblist= saltio.readgaindb(gaindb)
xtalkfile = xtalkfile.strip()
xdict = saltio.readxtalkcoeff(xtalkfile)
else:
dblist=[]
xdict=None
for img, oimg in zip(infiles, outfiles):
#open the fits file
struct=saltio.openfits(img)
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot = saltkey.instrumid(struct)
# has file been prepared already?
if saltkey.found(keygain, struct[0]):
message='%s has already been reduced' % img
raise SaltError(message)
# housekeeping keywords
fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0],keyslot, 'Images have been slotmode reduced', hist)
# write FITS file
saltio.writefits(struct,oimg, clobber=clobber)
saltio.closefits(struct)
def make_mosaic(struct, gap, xshift, yshift, rotation, interp_type='linear',
boundary='constant', constant=0, geotran=True, fill=False,
cleanup=True, log=None, verbose=False):
"""Given a SALT image struct, combine each of the individual amplifiers and
apply the geometric CCD transformations to the image
"""
# get the name of the file
infile = saltkey.getimagename(struct[0], base=True)
outpath = './'
# identify instrument
instrume, keyprep, keygain, keybias, keyxtalk, keyslot = \
saltkey.instrumid(struct)
# how many amplifiers?
nsciext = saltkey.get('NSCIEXT', struct[0])
nextend = saltkey.get('NEXTEND', struct[0])
nccds = saltkey.get('NCCDS', struct[0])
amplifiers = nccds * 2
if nextend > nsciext:
varframe = True
else:
varframe = False
# CCD geometry coefficients
if (instrume == 'RSS' or instrume == 'PFIS'):
xsh = [0., xshift[0], 0., xshift[1]]
ysh = [0., yshift[0], 0., yshift[1]]
rot = [0., rotation[0], 0., rotation[1]]
elif instrume == 'SALTICAM':
xsh = [0., xshift[0], 0.]
ysh = [0., yshift[0], 0.]
rot = [0., rotation[0], 0]
# how many extensions?
nextend = saltkey.get('NEXTEND', struct[0])
# CCD on-chip binning
xbin, ybin = saltkey.ccdbin(struct[0])
# create temporary primary extension
outstruct = []
outstruct.append(struct[0])
# define temporary FITS file store tiled CCDs
tilefile = saltio.tmpfile(outpath)
tilefile += 'tile.fits'
if varframe:
tilehdu = [None] * (3 * int(nsciext / 2) + 1)
else:
tilehdu = [None] * int(nsciext / 2 + 1)
tilehdu[0] = fits.PrimaryHDU()
#tilehdu[0].header = struct[0].header
if log:
log.message('', with_stdout=verbose)
# iterate over amplifiers, stich them to produce file of CCD images
for i in range(int(nsciext / 2)):
hdu = i * 2 + 1
# amplifier = hdu%amplifiers
# if (amplifier == 0): amplifier = amplifiers
# read DATASEC keywords
datasec1 = saltkey.get('DATASEC', struct[hdu])
datasec2 = saltkey.get('DATASEC', struct[hdu + 1])
xdsec1, ydsec1 = saltstring.secsplit(datasec1)
xdsec2, ydsec2 = saltstring.secsplit(datasec2)
# read images
imdata1 = saltio.readimage(struct, hdu)
imdata2 = saltio.readimage(struct, hdu + 1)
# tile 2n amplifiers to yield n CCD images
outdata = numpy.zeros((ydsec1[1] +
abs(ysh[i +
1] /
ybin), xdsec1[1] +
xdsec2[1] +
abs(xsh[i +
1] /
xbin)), numpy.float32)
# set up the variance frame
if varframe:
vardata = outdata.copy()
vdata1 = saltio.readimage(struct, struct[hdu].header['VAREXT'])
vdata2 = saltio.readimage(struct, struct[hdu + 1].header['VAREXT'])
bpmdata = outdata.copy()
bdata1 = saltio.readimage(struct, struct[hdu].header['BPMEXT'])
bdata2 = saltio.readimage(struct, struct[hdu + 1].header['BPMEXT'])
x1 = xdsec1[0] - 1
if x1 != 0:
msg = 'The data in %s have not been trimmed prior to mosaicking.' \
% infile
log.error(msg)
if xsh[i + 1] < 0:
x1 += abs(xsh[i + 1] / xbin)
x2 = x1 + xdsec1[1]
y1 = ydsec1[0] - 1
if ysh[i + 1] < 0:
y1 += abs(ysh[i + 1] / ybin)
y2 = y1 + ydsec1[1]
outdata[y1:y2, x1:x2] =\
imdata1[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
if varframe:
vardata[y1:y2, x1:x2] =\
vdata1[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
bpmdata[y1:y2, x1:x2] =\
bdata1[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
x1 = x2
x2 = x1 + xdsec2[1]
y1 = ydsec2[0] - 1
if ysh[i + 1] < 0:
y1 += abs(ysh[i + 1] / ybin)
y2 = y1 + ydsec2[1]
outdata[y1:y2, x1:x2] =\
imdata2[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
if varframe:
vardata[y1:y2, x1:x2] =\
vdata2[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
bpmdata[y1:y2, x1:x2] =\
bdata2[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
# size of new image
naxis1 = str(xdsec1[1] + xdsec2[1])
naxis2 = str(ydsec1[1])
# add image and keywords to HDU list
tilehdu[i + 1] = fits.ImageHDU(outdata)
tilehdu[i + 1].header = struct[hdu].header
#tilehdu[
# i + 1].header['DATASEC'] = '[1:' + naxis1 + ',1:' + naxis2 + ']'
if varframe:
vext = i + 1 + int(nsciext / 2.)
tilehdu[vext] = fits.ImageHDU(vardata)
#tilehdu[vext].header = struct[struct[hdu].header['VAREXT']].header
#tilehdu[vext].header[
# 'DATASEC'] = '[1:' + naxis1 + ',1:' + naxis2 + ']'
bext = i + 1 + 2 * int(nsciext / 2.)
tilehdu[bext] = fits.ImageHDU(bpmdata)
#tilehdu[bext].header = struct[struct[hdu].header['BPMEXT']].header
#tilehdu[bext].header[
# 'DATASEC'] = '[1:' + naxis1 + ',1:' + naxis2 + ']'
# image tile log message #1
if log:
message = os.path.basename(infile) + '[' + str(hdu) + ']['
message += str(xdsec1[0]) + ':' + str(xdsec1[1]) + ','
message += str(ydsec1[0]) + ':' + str(ydsec1[1]) + '] --> '
message += os.path.basename(tilefile) + '[' + str(i + 1) + ']['
message += str(xdsec1[0]) + ':' + str(xdsec1[1]) + ','
message += str(ydsec1[0]) + ':' + str(ydsec1[1]) + ']'
log.message(message, with_stdout=verbose, with_header=False)
message = os.path.basename(infile) + '[' + str(hdu + 1) + ']['
message += str(xdsec1[0]) + ':' + str(xdsec1[1]) + ','
message += str(ydsec1[0]) + ':' + str(ydsec1[1]) + '] --> '
message += os.path.basename(tilefile) + '[' + str(i + 1) + ']['
message += str(xdsec1[1] + 1) + ':' + \
str(xdsec1[1] + xdsec2[1]) + ','
message += str(ydsec2[0]) + ':' + str(ydsec2[1]) + ']'
log.message(message, with_stdout=verbose, with_header=False)
# write temporary file of tiled CCDs
hdulist = fits.HDUList(tilehdu)
hdulist.writeto(tilefile)
# iterate over CCDs, transform and rotate images
yrot = [None] * 4
xrot = [None] * 4
tranfile = [' ']
tranhdu = [0]
if varframe:
tranfile = [''] * (3 * int(nsciext / 2) + 1)
tranhdu = [0] * (3 * int(nsciext / 2) + 1)
else:
tranfile = [''] * int(nsciext / 2 + 1)
tranhdu = [0] * int(nsciext / 2 + 1)
# this is hardwired for SALT where the second CCD is considered the
# fiducial
for hdu in range(1, int(nsciext / 2 + 1)):
tranfile[hdu] = saltio.tmpfile(outpath)
tranfile[hdu] += 'tran.fits'
if varframe:
tranfile[hdu + nccds] = saltio.tmpfile(outpath) + 'tran.fits'
tranfile[hdu + 2 * nccds] = saltio.tmpfile(outpath) + 'tran.fits'
ccd = hdu % nccds
if (ccd == 0):
ccd = nccds
# correct rotation for CCD binning
yrot[ccd] = rot[ccd] * ybin / xbin
xrot[ccd] = rot[ccd] * xbin / ybin
dxshift = xbin * int(float(int(gap) / xbin) + 0.5) - gap
# transformation using geotran IRAF task
# if (ccd == 1):
if (ccd != 2):
if geotran:
message = '\nSALTMOSAIC -- geotran ' + tilefile + \
'[' + str(ccd) + '] ' + tranfile[hdu]
message += ' \"\" \"\" xshift=' + \
str((xsh[ccd] + (2 - ccd) * dxshift) / xbin) + ' '
message += 'yshift=' + \
str(ysh[ccd] / ybin) + ' xrotation=' + str(xrot[ccd]) + ' '
message += 'yrotation=' + \
str(yrot[ccd]) + ' xmag=1 ymag=1 xmin=\'INDEF\''
message += 'xmax=\'INDEF\' ymin=\'INDEF\' ymax=\'INDEF\' '
message += 'ncols=\'INDEF\' '
message += 'nlines=\'INDEF\' verbose=\'no\' '
message += 'fluxconserve=\'yes\' nxblock=2048 '
message += 'nyblock=2048 interpolant=\'' + \
interp_type + '\' boundary=\'constant\' constant=0'
log.message(message, with_stdout=verbose)
yd, xd = tilehdu[ccd].data.shape
ncols = 'INDEF' # ncols=xd+abs(xsh[ccd]/xbin)
nlines = 'INDEF' # nlines=yd+abs(ysh[ccd]/ybin)
geo_xshift = xsh[ccd] + (2 - ccd) * dxshift / xbin
geo_yshift = ysh[ccd] / ybin
iraf.images.immatch.geotran(tilefile + "[" + str(ccd) + "]",
tranfile[hdu],
"",
"",
xshift=geo_xshift,
yshift=geo_yshift,
xrotation=xrot[ccd],
yrotation=yrot[ccd],
xmag=1, ymag=1, xmin='INDEF',
xmax='INDEF', ymin='INDEF',
ymax='INDEF', ncols=ncols,
nlines=nlines, verbose='no',
fluxconserve='yes', nxblock=2048,
nyblock=2048, interpolant="linear",
boundary="constant", constant=0)
if varframe:
var_infile = tilefile + "[" + str(ccd + nccds) + "]"
iraf.images.immatch.geotran(var_infile,
tranfile[hdu + nccds],
"",
"",
xshift=geo_xshift,
yshift=geo_yshift,
xrotation=xrot[ccd],
yrotation=yrot[ccd],
xmag=1, ymag=1, xmin='INDEF',
xmax='INDEF', ymin='INDEF',
ymax='INDEF', ncols=ncols,
nlines=nlines, verbose='no',
fluxconserve='yes',
nxblock=2048, nyblock=2048,
interpolant="linear",
boundary="constant",
constant=0)
var2_infile = tilefile + "[" + str(ccd + 2 * nccds) + "]"
iraf.images.immatch.geotran(var2_infile,
tranfile[hdu + 2 * nccds],
"",
"",
xshift=geo_xshift,
yshift=geo_yshift,
xrotation=xrot[ccd],
yrotation=yrot[ccd],
xmag=1, ymag=1, xmin='INDEF',
xmax='INDEF', ymin='INDEF',
ymax='INDEF', ncols=ncols,
nlines=nlines, verbose='no',
fluxconserve='yes',
nxblock=2048, nyblock=2048,
interpolant="linear",
boundary="constant",
constant=0)
# open the file and copy the data to tranhdu
tstruct = fits.open(tranfile[hdu])
tranhdu[hdu] = tstruct[0].data
tstruct.close()
if varframe:
tranhdu[
hdu +
nccds] = fits.open(
tranfile[
hdu +
nccds])[0].data
tranhdu[
hdu +
2 *
nccds] = fits.open(
tranfile[
hdu +
2 *
nccds])[0].data
else:
log.message(
"Transform CCD #%i using dx=%s, dy=%s, rot=%s" %
(ccd,
xsh[ccd] /
2.0,
ysh[ccd] /
2.0,
xrot[ccd]),
with_stdout=verbose,
with_header=False)
tranhdu[hdu] = geometric_transform(
tilehdu[ccd].data,
tran_func,
prefilter=False,
order=1,
extra_arguments=(
xsh[ccd] / 2,
ysh[ccd] / 2,
1,
1,
xrot[ccd],
yrot[ccd]))
tstruct = fits.PrimaryHDU(tranhdu[hdu])
tstruct.writeto(tranfile[hdu])
if varframe:
tranhdu[hdu + nccds] = geometric_transform(
tilehdu[hdu + 3].data,
tran_func,
prefilter=False,
order=1,
extra_arguments=(
xsh[ccd] / 2, ysh[ccd] / 2,
1, 1,
xrot[ccd], yrot[ccd]))
tranhdu[hdu + 2 * nccds] = geometric_transform(
tilehdu[hdu + 6].data,
tran_func,
prefilter=False,
order=1,
extra_arguments=(
xsh[ccd] / 2, ysh[ccd] / 2,
1, 1,
xrot[ccd], yrot[ccd]))
else:
log.message(
"Transform CCD #%i using dx=%s, dy=%s, rot=%s" %
(ccd, 0, 0, 0), with_stdout=verbose, with_header=False)
tranhdu[hdu] = tilehdu[ccd].data
if varframe:
tranhdu[hdu + nccds] = tilehdu[ccd + nccds].data
tranhdu[hdu + 2 * nccds] = tilehdu[ccd + 2 * nccds].data
# open outfile
if varframe:
outlist = 4 * [None]
else:
outlist = 2 * [None]
#outlist[0] = struct[0].copy()
outlist[0] = fits.PrimaryHDU()
outlist[0].header = struct[0].header
naxis1 = int(gap / xbin * (nccds - 1))
naxis2 = 0
for i in range(1, nccds + 1):
yw, xw = tranhdu[i].shape
naxis1 += xw + int(abs(xsh[ccd] / xbin)) + 1
naxis2 = max(naxis2, yw)
outdata = numpy.zeros((naxis2, naxis1), numpy.float32)
outdata.shape = naxis2, naxis1
if varframe:
vardata = outdata * 0
bpmdata = outdata * 0 + 1
# iterate over CCDs, stich them to produce a full image
hdu = 0
totxshift = 0
for hdu in range(1, nccds + 1):
# read DATASEC keywords
ydsec, xdsec = tranhdu[hdu].shape
# define size and shape of final image
# tile CCDs to yield mosaiced image
x1 = int((hdu - 1) * (xdsec + gap / xbin)) + int(totxshift)
x2 = xdsec + x1
y1 = int(0)
y2 = int(ydsec)
outdata[y1:y2, x1:x2] = tranhdu[hdu]
totxshift += int(abs(xsh[hdu] / xbin)) + 1
if varframe:
vardata[y1:y2, x1:x2] = tranhdu[hdu + nccds]
bpmdata[y1:y2, x1:x2] = tranhdu[hdu + 2 * nccds]
# make sure to cover up all the gaps include bad areas
if varframe:
baddata = (outdata == 0)
baddata = nd.maximum_filter(baddata, size=3)
bpmdata[baddata] = 1
# fill in the gaps if requested
if fill:
if varframe:
outdata = fill_gaps(outdata, 0)
else:
outdata = fill_gaps(outdata, 0)
# add to the file
outlist[1] = fits.ImageHDU(outdata)
if varframe:
outlist[2] = fits.ImageHDU(vardata,name='VAR')
outlist[3] = fits.ImageHDU(bpmdata,name='BPM')
# create the image structure
outstruct = fits.HDUList(outlist)
# update the head informaation
# housekeeping keywords
saltkey.put('NEXTEND', 2, outstruct[0])
saltkey.new('EXTNAME', 'SCI', 'Extension name', outstruct[1])
saltkey.new('EXTVER', 1, 'Extension number', outstruct[1])
if varframe:
saltkey.new('VAREXT', 2, 'Variance frame extension', outstruct[1])
saltkey.new('BPMEXT', 3, 'BPM Extension', outstruct[1])
try:
saltkey.copy(struct[1], outstruct[1], 'CCDSUM')
except:
pass
# Add keywords associated with geometry
saltkey.new('SGEOMGAP', gap, 'SALT Chip Gap', outstruct[0])
c1str = '{:3.2f} {:3.2f} {:3.4f}'.format(xshift[0],
yshift[0],
rotation[0])
saltkey.new('SGEOM1', c1str, 'SALT Chip 1 Transform', outstruct[0])
c2str = '{:3.2f} {:3.2f} {:3.4f}'.format(xshift[1],
yshift[1],
rotation[1])
saltkey.new('SGEOM2', c2str, 'SALT Chip 2 Transform', outstruct[0])
# WCS keywords
saltkey.new('CRPIX1', 0, 'WCS: X reference pixel', outstruct[1])
saltkey.new('CRPIX2', 0, 'WCS: Y reference pixel', outstruct[1])
saltkey.new(
'CRVAL1',
float(xbin),
'WCS: X reference coordinate value',
outstruct[1])
saltkey.new(
'CRVAL2',
float(ybin),
'WCS: Y reference coordinate value',
outstruct[1])
saltkey.new('CDELT1', float(xbin), 'WCS: X pixel size', outstruct[1])
saltkey.new('CDELT2', float(ybin), 'WCS: Y pixel size', outstruct[1])
saltkey.new('CTYPE1', 'pixel', 'X type', outstruct[1])
saltkey.new('CTYPE2', 'pixel', 'Y type', outstruct[1])
# cleanup temporary files
if cleanup:
for tfile in tranfile:
if os.path.isfile(tfile):
saltio.delete(tfile)
if os.path.isfile(tilefile):
status = saltio.delete(tilefile)
# return the file
return outstruct
def make_mosaic(struct,
gap,
xshift,
yshift,
rotation,
interp_type='linear',
boundary='constant',
constant=0,
geotran=True,
fill=False,
cleanup=True,
log=None,
verbose=False):
"""Given a SALT image struct, combine each of the individual amplifiers and
apply the geometric CCD transformations to the image
"""
# get the name of the file
infile = saltkey.getimagename(struct[0], base=True)
outpath = './'
# identify instrument
instrume, keyprep, keygain, keybias, keyxtalk, keyslot = \
saltkey.instrumid(struct)
# how many amplifiers?
nsciext = saltkey.get('NSCIEXT', struct[0])
nextend = saltkey.get('NEXTEND', struct[0])
nccds = saltkey.get('NCCDS', struct[0])
amplifiers = nccds * 2
if nextend > nsciext:
varframe = True
else:
varframe = False
# CCD geometry coefficients
if (instrume == 'RSS' or instrume == 'PFIS'):
xsh = [0., xshift[0], 0., xshift[1]]
ysh = [0., yshift[0], 0., yshift[1]]
rot = [0., rotation[0], 0., rotation[1]]
elif instrume == 'SALTICAM':
xsh = [0., xshift[0], 0.]
ysh = [0., yshift[0], 0.]
rot = [0., rotation[0], 0]
# how many extensions?
nextend = saltkey.get('NEXTEND', struct[0])
# CCD on-chip binning
xbin, ybin = saltkey.ccdbin(struct[0])
# create temporary primary extension
outstruct = []
outstruct.append(struct[0])
# define temporary FITS file store tiled CCDs
tilefile = saltio.tmpfile(outpath)
tilefile += 'tile.fits'
if varframe:
tilehdu = [None] * (3 * int(nsciext / 2) + 1)
else:
tilehdu = [None] * int(nsciext / 2 + 1)
tilehdu[0] = fits.PrimaryHDU()
#tilehdu[0].header = struct[0].header
if log:
log.message('', with_stdout=verbose)
# iterate over amplifiers, stich them to produce file of CCD images
for i in range(int(nsciext / 2)):
hdu = i * 2 + 1
# amplifier = hdu%amplifiers
# if (amplifier == 0): amplifier = amplifiers
# read DATASEC keywords
datasec1 = saltkey.get('DATASEC', struct[hdu])
datasec2 = saltkey.get('DATASEC', struct[hdu + 1])
xdsec1, ydsec1 = saltstring.secsplit(datasec1)
xdsec2, ydsec2 = saltstring.secsplit(datasec2)
# read images
imdata1 = saltio.readimage(struct, hdu)
imdata2 = saltio.readimage(struct, hdu + 1)
# tile 2n amplifiers to yield n CCD images
outdata = numpy.zeros(
(int(ydsec1[1] + abs(ysh[i + 1] / ybin)),
int(xdsec1[1] + xdsec2[1] + abs(xsh[i + 1] / xbin))),
numpy.float32)
# set up the variance frame
if varframe:
vardata = outdata.copy()
vdata1 = saltio.readimage(struct, struct[hdu].header['VAREXT'])
vdata2 = saltio.readimage(struct, struct[hdu + 1].header['VAREXT'])
bpmdata = outdata.copy()
bdata1 = saltio.readimage(struct, struct[hdu].header['BPMEXT'])
bdata2 = saltio.readimage(struct, struct[hdu + 1].header['BPMEXT'])
x1 = xdsec1[0] - 1
if x1 != 0:
msg = 'The data in %s have not been trimmed prior to mosaicking.' \
% infile
log.error(msg)
if xsh[i + 1] < 0:
x1 += int(abs(xsh[i + 1] / xbin))
x2 = x1 + xdsec1[1]
y1 = ydsec1[0] - 1
if ysh[i + 1] < 0:
y1 += int(abs(ysh[i + 1] / ybin))
y2 = y1 + ydsec1[1]
outdata[y1:y2, x1:x2] =\
imdata1[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
if varframe:
vardata[y1:y2, x1:x2] =\
vdata1[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
bpmdata[y1:y2, x1:x2] =\
bdata1[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
x1 = x2
x2 = x1 + xdsec2[1]
y1 = ydsec2[0] - 1
if ysh[i + 1] < 0:
y1 += abs(ysh[i + 1] / ybin)
y2 = y1 + ydsec2[1]
outdata[y1:y2, x1:x2] =\
imdata2[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
if varframe:
vardata[y1:y2, x1:x2] =\
vdata2[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
bpmdata[y1:y2, x1:x2] =\
bdata2[ydsec1[0] - 1:ydsec1[1], xdsec1[0] - 1:xdsec1[1]]
# size of new image
naxis1 = str(xdsec1[1] + xdsec2[1])
naxis2 = str(ydsec1[1])
# add image and keywords to HDU list
tilehdu[i + 1] = fits.ImageHDU(outdata)
tilehdu[i + 1].header = struct[hdu].header
#tilehdu[
# i + 1].header['DATASEC'] = '[1:' + naxis1 + ',1:' + naxis2 + ']'
if varframe:
vext = i + 1 + int(nsciext / 2.)
tilehdu[vext] = fits.ImageHDU(vardata)
#tilehdu[vext].header = struct[struct[hdu].header['VAREXT']].header
#tilehdu[vext].header[
# 'DATASEC'] = '[1:' + naxis1 + ',1:' + naxis2 + ']'
bext = i + 1 + 2 * int(nsciext / 2.)
tilehdu[bext] = fits.ImageHDU(bpmdata)
#tilehdu[bext].header = struct[struct[hdu].header['BPMEXT']].header
#tilehdu[bext].header[
# 'DATASEC'] = '[1:' + naxis1 + ',1:' + naxis2 + ']'
# image tile log message #1
if log:
message = os.path.basename(infile) + '[' + str(hdu) + ']['
message += str(xdsec1[0]) + ':' + str(xdsec1[1]) + ','
message += str(ydsec1[0]) + ':' + str(ydsec1[1]) + '] --> '
message += os.path.basename(tilefile) + '[' + str(i + 1) + ']['
message += str(xdsec1[0]) + ':' + str(xdsec1[1]) + ','
message += str(ydsec1[0]) + ':' + str(ydsec1[1]) + ']'
log.message(message, with_stdout=verbose, with_header=False)
message = os.path.basename(infile) + '[' + str(hdu + 1) + ']['
message += str(xdsec1[0]) + ':' + str(xdsec1[1]) + ','
message += str(ydsec1[0]) + ':' + str(ydsec1[1]) + '] --> '
message += os.path.basename(tilefile) + '[' + str(i + 1) + ']['
message += str(xdsec1[1] + 1) + ':' + \
str(xdsec1[1] + xdsec2[1]) + ','
message += str(ydsec2[0]) + ':' + str(ydsec2[1]) + ']'
log.message(message, with_stdout=verbose, with_header=False)
# write temporary file of tiled CCDs
hdulist = fits.HDUList(tilehdu)
hdulist.writeto(tilefile)
# iterate over CCDs, transform and rotate images
yrot = [None] * 4
xrot = [None] * 4
tranfile = [' ']
tranhdu = [0]
if varframe:
tranfile = [''] * (3 * int(nsciext / 2) + 1)
tranhdu = [0] * (3 * int(nsciext / 2) + 1)
else:
tranfile = [''] * int(nsciext / 2 + 1)
tranhdu = [0] * int(nsciext / 2 + 1)
# this is hardwired for SALT where the second CCD is considered the
# fiducial
for hdu in range(1, int(nsciext / 2 + 1)):
tranfile[hdu] = saltio.tmpfile(outpath)
tranfile[hdu] += 'tran.fits'
if varframe:
tranfile[hdu + nccds] = saltio.tmpfile(outpath) + 'tran.fits'
tranfile[hdu + 2 * nccds] = saltio.tmpfile(outpath) + 'tran.fits'
ccd = hdu % nccds
if (ccd == 0):
ccd = nccds
# correct rotation for CCD binning
yrot[ccd] = rot[ccd] * ybin / xbin
xrot[ccd] = rot[ccd] * xbin / ybin
dxshift = xbin * int(float(int(gap) / xbin) + 0.5) - gap
# transformation using geotran IRAF task
# if (ccd == 1):
if (ccd != 2):
if geotran:
message = '\nSALTMOSAIC -- geotran ' + tilefile + \
'[' + str(ccd) + '] ' + tranfile[hdu]
message += ' \"\" \"\" xshift=' + \
str((xsh[ccd] + (2 - ccd) * dxshift) / xbin) + ' '
message += 'yshift=' + \
str(ysh[ccd] / ybin) + ' xrotation=' + str(xrot[ccd]) + ' '
message += 'yrotation=' + \
str(yrot[ccd]) + ' xmag=1 ymag=1 xmin=\'INDEF\''
message += 'xmax=\'INDEF\' ymin=\'INDEF\' ymax=\'INDEF\' '
message += 'ncols=\'INDEF\' '
message += 'nlines=\'INDEF\' verbose=\'no\' '
message += 'fluxconserve=\'yes\' nxblock=2048 '
message += 'nyblock=2048 interpolant=\'' + \
interp_type + '\' boundary=\'constant\' constant=0'
log.message(message, with_stdout=verbose)
yd, xd = tilehdu[ccd].data.shape
ncols = 'INDEF' # ncols=xd+abs(xsh[ccd]/xbin)
nlines = 'INDEF' # nlines=yd+abs(ysh[ccd]/ybin)
geo_xshift = xsh[ccd] + (2 - ccd) * dxshift / xbin
geo_yshift = ysh[ccd] / ybin
iraf.images.immatch.geotran(tilefile + "[" + str(ccd) + "]",
tranfile[hdu],
"",
"",
xshift=geo_xshift,
yshift=geo_yshift,
xrotation=xrot[ccd],
yrotation=yrot[ccd],
xmag=1,
ymag=1,
xmin='INDEF',
xmax='INDEF',
ymin='INDEF',
ymax='INDEF',
ncols=ncols,
nlines=nlines,
verbose='no',
fluxconserve='yes',
nxblock=2048,
nyblock=2048,
interpolant="linear",
boundary="constant",
constant=0)
if varframe:
var_infile = tilefile + "[" + str(ccd + nccds) + "]"
iraf.images.immatch.geotran(var_infile,
tranfile[hdu + nccds],
"",
"",
xshift=geo_xshift,
yshift=geo_yshift,
xrotation=xrot[ccd],
yrotation=yrot[ccd],
xmag=1,
ymag=1,
xmin='INDEF',
xmax='INDEF',
ymin='INDEF',
ymax='INDEF',
ncols=ncols,
nlines=nlines,
verbose='no',
fluxconserve='yes',
nxblock=2048,
nyblock=2048,
interpolant="linear",
boundary="constant",
constant=0)
var2_infile = tilefile + "[" + str(ccd + 2 * nccds) + "]"
iraf.images.immatch.geotran(var2_infile,
tranfile[hdu + 2 * nccds],
"",
"",
xshift=geo_xshift,
yshift=geo_yshift,
xrotation=xrot[ccd],
yrotation=yrot[ccd],
xmag=1,
ymag=1,
xmin='INDEF',
xmax='INDEF',
ymin='INDEF',
ymax='INDEF',
ncols=ncols,
nlines=nlines,
verbose='no',
fluxconserve='yes',
nxblock=2048,
nyblock=2048,
interpolant="linear",
boundary="constant",
constant=0)
# open the file and copy the data to tranhdu
tstruct = fits.open(tranfile[hdu])
tranhdu[hdu] = tstruct[0].data
tstruct.close()
if varframe:
tranhdu[hdu + nccds] = fits.open(tranfile[hdu +
nccds])[0].data
tranhdu[hdu + 2 * nccds] = fits.open(
tranfile[hdu + 2 * nccds])[0].data
else:
log.message("Transform CCD #%i using dx=%s, dy=%s, rot=%s" %
(ccd, xsh[ccd] / 2.0, ysh[ccd] / 2.0, xrot[ccd]),
with_stdout=verbose,
with_header=False)
tranhdu[hdu] = geometric_transform(
tilehdu[ccd].data,
tran_func,
prefilter=False,
order=1,
extra_arguments=(xsh[ccd] / 2, ysh[ccd] / 2, 1, 1,
xrot[ccd], yrot[ccd]))
tstruct = fits.PrimaryHDU(tranhdu[hdu])
tstruct.writeto(tranfile[hdu])
if varframe:
tranhdu[hdu + nccds] = geometric_transform(
tilehdu[hdu + 3].data,
tran_func,
prefilter=False,
order=1,
extra_arguments=(xsh[ccd] / 2, ysh[ccd] / 2, 1, 1,
xrot[ccd], yrot[ccd]))
tranhdu[hdu + 2 * nccds] = geometric_transform(
tilehdu[hdu + 6].data,
tran_func,
prefilter=False,
order=1,
extra_arguments=(xsh[ccd] / 2, ysh[ccd] / 2, 1, 1,
xrot[ccd], yrot[ccd]))
else:
log.message("Transform CCD #%i using dx=%s, dy=%s, rot=%s" %
(ccd, 0, 0, 0),
with_stdout=verbose,
with_header=False)
tranhdu[hdu] = tilehdu[ccd].data
if varframe:
tranhdu[hdu + nccds] = tilehdu[ccd + nccds].data
tranhdu[hdu + 2 * nccds] = tilehdu[ccd + 2 * nccds].data
# open outfile
if varframe:
outlist = 4 * [None]
else:
outlist = 2 * [None]
#outlist[0] = struct[0].copy()
outlist[0] = fits.PrimaryHDU()
outlist[0].header = struct[0].header
naxis1 = int(gap / xbin * (nccds - 1))
naxis2 = 0
for i in range(1, nccds + 1):
yw, xw = tranhdu[i].shape
naxis1 += xw + int(abs(xsh[ccd] / xbin)) + 1
naxis2 = max(naxis2, yw)
outdata = numpy.zeros((naxis2, naxis1), numpy.float32)
outdata.shape = naxis2, naxis1
if varframe:
vardata = outdata * 0
bpmdata = outdata * 0 + 1
# iterate over CCDs, stich them to produce a full image
hdu = 0
totxshift = 0
for hdu in range(1, nccds + 1):
# read DATASEC keywords
ydsec, xdsec = tranhdu[hdu].shape
# define size and shape of final image
# tile CCDs to yield mosaiced image
x1 = int((hdu - 1) * (xdsec + gap / xbin)) + int(totxshift)
x2 = xdsec + x1
y1 = int(0)
y2 = int(ydsec)
outdata[y1:y2, x1:x2] = tranhdu[hdu]
totxshift += int(abs(xsh[hdu] / xbin)) + 1
if varframe:
vardata[y1:y2, x1:x2] = tranhdu[hdu + nccds]
bpmdata[y1:y2, x1:x2] = tranhdu[hdu + 2 * nccds]
# make sure to cover up all the gaps include bad areas
if varframe:
baddata = (outdata == 0)
baddata = nd.maximum_filter(baddata, size=3)
bpmdata[baddata] = 1
# fill in the gaps if requested
if fill:
if varframe:
outdata = fill_gaps(outdata, 0)
else:
outdata = fill_gaps(outdata, 0)
# add to the file
outlist[1] = fits.ImageHDU(outdata)
if varframe:
outlist[2] = fits.ImageHDU(vardata, name='VAR')
outlist[3] = fits.ImageHDU(bpmdata, name='BPM')
# create the image structure
outstruct = fits.HDUList(outlist)
# update the head informaation
# housekeeping keywords
saltkey.put('NEXTEND', 2, outstruct[0])
saltkey.new('EXTNAME', 'SCI', 'Extension name', outstruct[1])
saltkey.new('EXTVER', 1, 'Extension number', outstruct[1])
if varframe:
saltkey.new('VAREXT', 2, 'Variance frame extension', outstruct[1])
saltkey.new('BPMEXT', 3, 'BPM Extension', outstruct[1])
try:
saltkey.copy(struct[1], outstruct[1], 'CCDSUM')
except:
pass
# Add keywords associated with geometry
saltkey.new('SGEOMGAP', gap, 'SALT Chip Gap', outstruct[0])
c1str = '{:3.2f} {:3.2f} {:3.4f}'.format(xshift[0], yshift[0], rotation[0])
saltkey.new('SGEOM1', c1str, 'SALT Chip 1 Transform', outstruct[0])
c2str = '{:3.2f} {:3.2f} {:3.4f}'.format(xshift[1], yshift[1], rotation[1])
saltkey.new('SGEOM2', c2str, 'SALT Chip 2 Transform', outstruct[0])
# WCS keywords
saltkey.new('CRPIX1', 0, 'WCS: X reference pixel', outstruct[1])
saltkey.new('CRPIX2', 0, 'WCS: Y reference pixel', outstruct[1])
saltkey.new('CRVAL1', float(xbin), 'WCS: X reference coordinate value',
outstruct[1])
saltkey.new('CRVAL2', float(ybin), 'WCS: Y reference coordinate value',
outstruct[1])
saltkey.new('CDELT1', float(xbin), 'WCS: X pixel size', outstruct[1])
saltkey.new('CDELT2', float(ybin), 'WCS: Y pixel size', outstruct[1])
saltkey.new('CTYPE1', 'pixel', 'X type', outstruct[1])
saltkey.new('CTYPE2', 'pixel', 'Y type', outstruct[1])
# cleanup temporary files
if cleanup:
for tfile in tranfile:
if os.path.isfile(tfile):
saltio.delete(tfile)
if os.path.isfile(tilefile):
status = saltio.delete(tilefile)
# return the file
return outstruct
def saltbias(images,
outimages,
outpref,
subover=True,
trim=True,
subbias=False,
masterbias='bias.fits',
median=False,
function='polynomial',
order=3,
rej_lo=3,
rej_hi=3,
niter=10,
plotover=False,
turbo=False,
clobber=False,
logfile='salt.log',
verbose=True):
status = 0
ifil = 0
ii = 0
mbiasdata = []
bstruct = ''
biasgn = ''
biassp = ''
biasbn = ''
biasin = ''
filetime = {}
biastime = {}
for i in range(1, 7):
filetime[i] = []
biastime[i] = []
with logging(logfile, debug) as log:
# Check the input images
infiles = saltio.argunpack('Input', images)
# create list of output files
outfiles = saltio.listparse('Outfile', outimages, outpref, infiles, '')
# are input and output lists the same length?
saltio.comparelists(infiles, outfiles, 'Input', 'output')
# Does master bias frame exist?
# gain, speed, binning and instrument of master bias frame
if subbias:
if os.path.isfile(masterbias):
bstruct = saltio.openfits(masterbias)
else:
message = 'Master bias frame %s does not exist' % masterbias
raise SaltError(message)
else:
bstruct = None
# open each raw image file
for img, oimg in zip(infiles, outfiles):
#open the file
struct = saltio.openfits(img)
#check to see if it has already been bias subtracted
instrume, keyprep, keygain, keybias, keyxtalk, keyslot = saltkey.instrumid(
struct)
# has file been biaseded already?
try:
key = struct[0].header[keybias]
message = 'File %s has already been de-biased ' % infile
raise SaltError(message)
except:
pass
#compare with the master bias to make sure they are the same
if subbias:
pass
#subtract the bias
struct = bias(struct,
subover=subover,
trim=trim,
subbias=subbias,
bstruct=bstruct,
median=median,
function=function,
order=order,
rej_lo=rej_lo,
rej_hi=rej_hi,
niter=niter,
plotover=plotover,
log=log,
verbose=verbose)
#write the file out
# housekeeping keywords
fname, hist = history(level=1,
wrap=False,
exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0], keybias,
'Images have been de-biased', hist)
# write FITS file
saltio.writefits(struct, oimg, clobber=clobber)
saltio.closefits(struct)
def slotmerge(images, outimages, outpref, geomfile, clobber, logfile, verbose):
with logging(logfile, debug) as log:
# are the arguments defined
saltsafeio.argdefined('images', images)
saltsafeio.argdefined('geomfile', geomfile)
saltsafeio.argdefined('logfile', logfile)
# if the input file is a list, does it exist?
if images[0] == '@':
saltsafeio.listexists('Input', images)
# parse list of input files
infiles = saltsafeio.listparse('Raw image', images, '', '', '')
# check input files exist
saltsafeio.filesexist(infiles, '', 'r')
# load output name list: @list, * and comma separated
outimages = outimages.strip()
outpref = outpref.strip()
if len(outpref) == 0 and len(outimages) == 0:
raise SaltIOError('Output file(s) not specified')
# test output @filelist exists
if len(outimages) > 0 and outimages[0] == '@':
saltsafeio.listexists('Output', outimages)
# parse list of output files
outfiles = saltsafeio.listparse('Output image', outimages, outpref,
infiles, '')
# are input and output lists the same length?
saltsafeio.comparelists(infiles, outfiles, 'Input', 'output')
# do the output files already exist?
if not clobber:
saltsafeio.filesexist(outfiles, '', 'w')
# does CCD geometry definition file exist
geomfilefile = geomfile.strip()
saltsafeio.fileexists(geomfile)
# read geometry definition file
gap = 0
xshift = [0, 0]
yshift = [0, 0]
rotation = [0, 0]
gap, xshift, yshift, rotation = saltsafeio.readccdgeom(geomfile)
for ro in rotation:
if ro != 0:
log.warning('SLOTMERGE currently ignores CCD rotation')
# Begin processes each file
for infile, outfile in zip(infiles, outfiles):
# determine the name for the output file
outpath = outfile.rstrip(os.path.basename(outfile))
if (len(outpath) == 0):
outpath = '.'
# open each raw image
struct = saltsafeio.openfits(infile)
# identify instrument
instrume, keyprep, keygain, keybias, keyxtalk, keyslot = saltsafekey.instrumid(
struct, infile)
# how many amplifiers?
nccds = saltsafekey.get('NCCDS', struct[0], infile)
amplifiers = nccds * 2
#if (nccds != 2):
# raise SaltError('Can not currently handle more than two CCDs')
# CCD geometry coefficients
if instrume == 'RSS' or instrume == 'PFIS':
xsh = [xshift[0], 0., xshift[1]]
ysh = [yshift[0], 0., yshift[1]]
rot = [rotation[0], 0., rotation[1]]
refid = 1
if instrume == 'SALTICAM':
xsh = [xshift[0], 0.]
ysh = [yshift[0], 0.]
rot = [rotation[0], 0]
refid = 1
# how many extensions?
nextend = saltsafekey.get('NEXTEND', struct[0], infile)
# how many exposures
exposures = nextend / amplifiers
# CCD on-chip binning
xbin, ybin = saltsafekey.ccdbin(struct[0], infile)
gp = int(gap / xbin)
# create output hdu structure
outstruct = [None] * int(exposures + 1)
outstruct[0] = struct[0]
# iterate over exposures, stitch them to produce file of CCD images
for i in range(exposures):
# Determine the total size of the image
xsize = 0
ysize = 0
for j in range(amplifiers):
hdu = i * amplifiers + j + 1
try:
xsize += len(struct[hdu].data[0])
if ysize < len(struct[hdu].data):
ysize = len(struct[hdu].data)
except:
msg = 'Unable to access extension %i ' % hdu
raise SaltIOError(msg)
xsize += gp * (nccds - 1)
maxxsh, minxsh = determineshifts(xsh)
maxysh, minysh = determineshifts(ysh)
xsize += (maxxsh - minxsh)
ysize += (maxysh - minysh)
# Determine the x and y origins for each frame
xdist = 0
ydist = 0
shid = 0
x0 = np.zeros(amplifiers)
y0 = np.zeros(amplifiers)
for j in range(amplifiers):
x0[j] = xdist + xsh[shid] - minxsh
y0[j] = ysh[shid] - minysh
hdu = i * amplifiers + j + 1
darr = struct[hdu].data
xdist += len(darr[0])
if j % 2 == 1:
xdist += gp
shid += 1
# make the out image
outarr = np.zeros((ysize, xsize), np.float64)
# Embed each frame into the output array
for j in range(amplifiers):
hdu = i * amplifiers + j + 1
darr = struct[hdu].data
outarr = salttran.embed(darr, x0[j], y0[j], outarr)
# Add the outimage to the output structure
hdu = i * amplifiers + 1
outhdu = i + 1
outstruct[outhdu] = pyfits.ImageHDU(outarr)
outstruct[outhdu].header = struct[hdu].header
# Fix the headers in each extension
datasec = '[1:%4i,1:%4i]' % (xsize, ysize)
saltsafekey.put('DATASEC', datasec, outstruct[outhdu], outfile)
saltsafekey.rem('DETSIZE', outstruct[outhdu], outfile)
saltsafekey.rem('DETSEC', outstruct[outhdu], outfile)
saltsafekey.rem('CCDSEC', outstruct[outhdu], outfile)
saltsafekey.rem('AMPSEC', outstruct[outhdu], outfile)
# add housekeeping key words
outstruct[outhdu] = addhousekeeping(outstruct[outhdu], outhdu,
outfile)
# close input FITS file
saltsafeio.closefits(struct)
# housekeeping keywords
keymosaic = 'SLOTMERG'
fname, hist = history(level=1, wrap=False)
saltsafekey.housekeeping(struct[0], keymosaic,
'Amplifiers have been mosaiced', hist)
#saltsafekey.history(outstruct[0],hist)
# this is added for later use by
saltsafekey.put('NCCDS', 0.5, outstruct[0])
saltsafekey.put('NSCIEXT', exposures, outstruct[0])
saltsafekey.put('NEXTEND', exposures, outstruct[0])
# write FITS file of mosaiced image
outstruct = pyfits.HDUList(outstruct)
saltsafeio.writefits(outstruct, outfile, clobber=clobber)
def slotmerge(images,outimages,outpref,geomfile,clobber,logfile,verbose):
with logging(logfile,debug) as log:
# are the arguments defined
saltsafeio.argdefined('images',images)
saltsafeio.argdefined('geomfile',geomfile)
saltsafeio.argdefined('logfile',logfile)
# if the input file is a list, does it exist?
if images[0] == '@':
saltsafeio.listexists('Input',images)
# parse list of input files
infiles=saltsafeio.listparse('Raw image',images,'','','')
# check input files exist
saltsafeio.filesexist(infiles,'','r')
# load output name list: @list, * and comma separated
outimages = outimages.strip()
outpref = outpref.strip()
if len(outpref) == 0 and len(outimages) == 0:
raise SaltIOError('Output file(s) not specified')
# test output @filelist exists
if len(outimages) > 0 and outimages[0] == '@':
saltsafeio.listexists('Output',outimages)
# parse list of output files
outfiles=saltsafeio.listparse('Output image',outimages,outpref,infiles,'')
# are input and output lists the same length?
saltsafeio.comparelists(infiles,outfiles,'Input','output')
# do the output files already exist?
if not clobber:
saltsafeio.filesexist(outfiles,'','w')
# does CCD geometry definition file exist
geomfilefile = geomfile.strip()
saltsafeio.fileexists(geomfile)
# read geometry definition file
gap = 0
xshift = [0, 0]
yshift = [0, 0]
rotation = [0, 0]
gap, xshift, yshift, rotation=saltsafeio.readccdgeom(geomfile)
for ro in rotation:
if ro!=0:
log.warning('SLOTMERGE currently ignores CCD rotation')
# Begin processes each file
for infile, outfile in zip(infiles, outfiles):
# determine the name for the output file
outpath = outfile.rstrip(os.path.basename(outfile))
if (len(outpath) == 0):
outpath = '.'
# open each raw image
struct=saltsafeio.openfits(infile)
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot=saltsafekey.instrumid(struct,infile)
# how many amplifiers?
nccds=saltsafekey.get('NCCDS',struct[0],infile)
amplifiers = nccds * 2
#if (nccds != 2):
# raise SaltError('Can not currently handle more than two CCDs')
# CCD geometry coefficients
if instrume == 'RSS' or instrume == 'PFIS':
xsh = [xshift[0], 0., xshift[1]]
ysh = [yshift[0], 0., yshift[1]]
rot = [rotation[0], 0., rotation[1]]
refid = 1
if instrume == 'SALTICAM':
xsh = [xshift[0], 0.]
ysh = [yshift[0], 0.]
rot = [rotation[0], 0]
refid = 1
# how many extensions?
nextend=saltsafekey.get('NEXTEND',struct[0],infile)
# how many exposures
exposures = nextend/amplifiers
# CCD on-chip binning
xbin, ybin=saltsafekey.ccdbin(struct[0],infile)
gp = int(gap / xbin)
# create output hdu structure
outstruct = [None] * int(exposures+1)
outstruct[0]=struct[0]
# iterate over exposures, stitch them to produce file of CCD images
for i in range(exposures):
# Determine the total size of the image
xsize=0
ysize=0
for j in range(amplifiers):
hdu=i*amplifiers+j+1
try:
xsize += len(struct[hdu].data[0])
if ysize < len(struct[hdu].data):
ysize=len(struct[hdu].data)
except:
msg='Unable to access extension %i ' % hdu
raise SaltIOError(msg)
xsize += gp* (nccds-1)
maxxsh, minxsh = determineshifts(xsh)
maxysh, minysh = determineshifts(ysh)
xsize += (maxxsh-minxsh)
ysize += (maxysh-minysh)
# Determine the x and y origins for each frame
xdist=0
ydist=0
shid=0
x0=np.zeros(amplifiers)
y0=np.zeros(amplifiers)
for j in range(amplifiers):
x0[j]=xdist+xsh[shid]-minxsh
y0[j]=ysh[shid]-minysh
hdu=i*amplifiers+j+1
darr=struct[hdu].data
xdist += len(darr[0])
if j%2==1:
xdist += gp
shid += 1
# make the out image
outarr=np.zeros((ysize, xsize), np.float64)
# Embed each frame into the output array
for j in range(amplifiers):
hdu=i*amplifiers+j+1
darr=struct[hdu].data
outarr=salttran.embed(darr, x0[j], y0[j], outarr)
# Add the outimage to the output structure
hdu=i*amplifiers+1
outhdu=i+1
outstruct[outhdu] = pyfits.ImageHDU(outarr)
outstruct[outhdu].header=struct[hdu].header
# Fix the headers in each extension
datasec='[1:%4i,1:%4i]' % (xsize, ysize)
saltsafekey.put('DATASEC',datasec, outstruct[outhdu], outfile)
saltsafekey.rem('DETSIZE',outstruct[outhdu],outfile)
saltsafekey.rem('DETSEC',outstruct[outhdu],outfile)
saltsafekey.rem('CCDSEC',outstruct[outhdu],outfile)
saltsafekey.rem('AMPSEC',outstruct[outhdu],outfile)
# add housekeeping key words
outstruct[outhdu]=addhousekeeping(outstruct[outhdu], outhdu, outfile)
# close input FITS file
saltsafeio.closefits(struct)
# housekeeping keywords
keymosaic='SLOTMERG'
fname, hist=history(level=1, wrap=False)
saltsafekey.housekeeping(struct[0],keymosaic,'Amplifiers have been mosaiced', hist)
#saltsafekey.history(outstruct[0],hist)
# this is added for later use by
saltsafekey.put('NCCDS', 0.5, outstruct[0])
saltsafekey.put('NSCIEXT', exposures, outstruct[0])
saltsafekey.put('NEXTEND', exposures, outstruct[0])
# write FITS file of mosaiced image
outstruct=pyfits.HDUList(outstruct)
saltsafeio.writefits(outstruct, outfile, clobber=clobber)
def slot(struct,infile,dbspeed,dbrate,dbgain,dbnoise,dbbias,dbamp,xcoeff,gaindb,xtalkfile,
logfile,verbose):
import saltprint, saltkey, saltio, saltstat, time
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot,status = saltkey.instrumid(struct,infile,logfile)
# number of image HDU
nextend = 0
while (status == 0):
try:
struct[nextend+1].header['XTENSION']
nextend += 1
except:
break
nccds,status = saltkey.get('NCCDS',struct[0],infile,logfile)
amplifiers = nccds * 2
if (nextend%(amplifiers) != 0):
message = '\nERROR -- SALTSLOT: Number of image extensions and'
message += 'number of amplifiers are not consistent'
status = saltprint.err(saltlog,message)
status = saltkey.new('NSCIEXT',nextend,'Number of science extensions',struct[0],infile,logfile)
status = saltkey.new('NEXTEND',nextend,'Number of data extensions',struct[0],infile,logfile)
# check image file and gain database are compatible
if (status == 0):
ngains = len(dbgain)
if (int(max(dbamp)) != amplifiers):
message = '\nERROR -- SALTGSLOT: ' + infile + ' contains ' + str(amplifiers) + ' amplifiers'
message += ', the gaindb file ' + gaindb + ' contains ' + str(max(dbamp)) + ' amplifiers'
status = saltprint.err(logfile,message)
# check image file and cross talk database are compatible
if (status == 0):
if (len(xcoeff)-1 != amplifiers):
message = '\nERROR -- SALTSLOT: ' + infile + ' contains ' + str(amplifiers) + ' amplifiers'
message += ', the cross talk file ' + xtalkfile + ' contains ' + str(len(xcoeff)-1) + ' amplifiers'
status = saltprint.err(logfile,message)
# housekeeping keywords
if (status == 0):
status = saltkey.put('SAL-TLM',time.asctime(time.localtime()),struct[0],infile,logfile)
status = saltkey.new(keyslot,time.asctime(time.localtime()),
'Data have been cleaned by SALTSLOT',struct[0],infile,logfile)
# keywords for image extensions
for i in range(nextend):
hdu = i + 1
status = saltkey.new('EXTNAME','SCI','Extension name',struct[hdu],infile,logfile)
status = saltkey.new('EXTVER',hdu,'Extension number',struct[hdu],infile,logfile)
# log coefficent table
if (status == 0):
message = '%30s %5s %4s %8s' % ('HDU','Gain','Bias','Xtalk')
saltprint.log(logfile,'\n ---------------------------------------------',verbose)
saltprint.log(logfile,message,verbose)
saltprint.log(logfile,' ---------------------------------------------',verbose)
# loop over image extensions
if (status == 0):
for i in range(nextend/2):
hdu = i * 2 + 1
amplifier = hdu%amplifiers
if (amplifier == 0): amplifier = amplifiers
if (status == 0):
value,status = saltkey.get('NAXIS1',struct[hdu],infile,logfile)
naxis1 = int(value)
if (status == 0):
value,status = saltkey.get('NAXIS1',struct[hdu+1],infile,logfile)
naxis2 = int(value)
if (status == 0 and hdu == 1): biassec, status = saltkey.get('BIASSEC',struct[hdu],infile,logfile)
if (status == 0 and hdu == 1):
ranges = biassec.lstrip('[').rstrip(']').split(',')
x1_1 = int(ranges[0].split(':')[0]) - 1
x2_1 = int(ranges[0].split(':')[1]) - 1
y1_1 = int(ranges[1].split(':')[0]) - 1
y2_1 = int(ranges[1].split(':')[1]) - 1
if (status == 0 and hdu == 1): biassec, status = saltkey.get('BIASSEC',struct[hdu+1],infile,logfile)
if (status == 0 and hdu == 1):
ranges = biassec.lstrip('[').rstrip(']').split(',')
x1_2 = int(ranges[0].split(':')[0]) - 1
x2_2 = int(ranges[0].split(':')[1]) - 1
y1_2 = int(ranges[1].split(':')[0]) - 1
y2_2 = int(ranges[1].split(':')[1]) - 1
if (status == 0 and hdu == 1): datasec,status = saltkey.get('DATASEC',struct[hdu],infile,logfile)
if (status == 0 and hdu == 1):
ranges = datasec.lstrip('[').rstrip(']').split(',')
dx1_1 = int(ranges[0].split(':')[0]) - 1
dx2_1 = int(ranges[0].split(':')[1])
dy1_1 = int(ranges[1].split(':')[0]) - 1
dy2_1 = int(ranges[1].split(':')[1])
if (status == 0 and hdu == 1): datasec,status = saltkey.get('DATASEC',struct[hdu+1],infile,logfile)
if (status == 0 and hdu == 1):
ranges = datasec.lstrip('[').rstrip(']').split(',')
dx1_2 = int(ranges[0].split(':')[0]) - 1
dx2_2 = int(ranges[0].split(':')[1])
dy1_2 = int(ranges[1].split(':')[0]) - 1
dy2_2 = int(ranges[1].split(':')[1])
if (status == 0 and dx2_1 - dx1_1 != dx2_2 - dx1_2):
message = 'ERROR -- SALTSLOT: HDUs '+infile
message += '['+str(hdu)+'] and '+infile+'['+str(hdu+1)+']'
message += ' have different dimensions'
status = saltprint.err(logfile,message)
# read speed and gain of each exposure
if (status == 0 and hdu == 1):
gainset,status = saltkey.get('GAINSET',struct[0],infile,logfile)
rospeed,status = saltkey.get('ROSPEED',struct[0],infile,logfile)
if (rospeed == 'NONE'):
saltprint.log(logfile," ",verbose)
message = "ERROR -- SALTSLOT: Readout speed is 'NONE' in "
message += "primary keywords of " + infile
status = saltprint.err(logfile,message)
# read raw images
if (status == 0):
imagedata1,status = saltio.readimage(struct,hdu,logfile)
imagedata2,status = saltio.readimage(struct,hdu+1,logfile)
# gain correction
if (status == 0):
for j in range(len(dbgain)):
if (gainset == dbrate[j] and rospeed == dbspeed[j] and amplifier == int(dbamp[j])):
try:
gain1 = float(dbgain[j])
imagedata1 *= gain1
except:
mesage = 'ERROR -- SALTSLOT: Cannot perform gain correction on image '
message += infile+'['+str(hdu)+']'
status = saltprint.err(logfile,message)
elif (gainset == dbrate[j] and rospeed == dbspeed[j] and amplifier + 1 == int(dbamp[j])):
try:
gain2 = float(dbgain[j])
imagedata2 *= gain2
except:
mesage = 'ERROR -- SALTSLOT: Cannot perform gain correction on image '
message += infile+'['+str(hdu+1)+']'
status = saltprint.err(logfile,message)
# crosstalk correction
if (status == 0):
revimage1 = imagedata1 * float(xcoeff[amplifier])
revimage2 = imagedata2 * float(xcoeff[amplifier+1])
for j in range(dx2_1-dx1_1+1):
imagedata1[:,j] -= revimage2[:,dx2_2-j-1]
imagedata2[:,j] -= revimage1[:,dx2_1-j-1]
# bias subtraction
if (status == 0):
overx_val_1 = []
overx_val_2 = []
for x in range(x1_1,x2_1+1):
list_1 = imagedata1[y1_1:y2_1,x] * 1.0
overx_val_1.append(saltstat.median(list_1,logfile))
overlevel_1 = saltstat.median(overx_val_1,logfile)
for x in range(x1_2,x2_2+1):
list_2 = imagedata2[y1_2:y2_2,x] * 1.0
overx_val_2.append(saltstat.median(list_2,logfile))
overlevel_2 = saltstat.median(overx_val_2,logfile)
imagedata1 -= overlevel_1
imagedata2 -= overlevel_2
# trim overscan
if (status == 0):
imagedata1 = imagedata1[dy1_1:dy2_1,dx1_1:dx2_1]
imagedata2 = imagedata2[dy1_2:dy2_2,dx1_2:dx2_2]
datasec = '[1:'+str(dx2_1-dx1_1)+',1:'+str(dy2_1-dy1_1)+']'
status = saltkey.put('DATASEC',datasec,struct[hdu],infile,logfile)
status = saltkey.rem('BIASSEC',struct[hdu],infile,logfile)
datasec = '[1:'+str(dx2_2-dx1_2)+',1:'+str(dy2_2-dy1_2)+']'
status = saltkey.put('DATASEC',datasec,struct[hdu+1],infile,logfile)
status = saltkey.rem('BIASSEC',struct[hdu+1],infile,logfile)
# log coefficient table
if (status == 0):
infilename = infile.split('/')
infilename = infilename[len(infilename)-1]
message = '%25s[%3d] %5.2f %4d %8.6f' % \
(infilename, hdu, gain1, overlevel_1, float(xcoeff[amplifier+1]))
saltprint.log(logfile,message,verbose)
message = '%25s[%3d] %5.2f %4d %8.6f' % \
(infilename, hdu+1, gain2, overlevel_2,float(xcoeff[amplifier]))
saltprint.log(logfile,message,verbose)
# update image in HDU structure
if (status == 0):
struct,status = saltio.writeimage(struct,hdu,imagedata1,logfile)
struct,status = saltio.writeimage(struct,hdu+1,imagedata2,logfile)
return struct, status
def saltxtalk(images,
outimages,
outpref,
xtalkfile=None,
usedb=False,
clobber=True,
logfile='salt.log',
verbose=True):
#start logging
with logging(logfile, debug) as log:
# Check the input images
infiles = saltio.argunpack('Input', images)
# create list of output files
outfiles = saltio.listparse('Outfile', outimages, outpref, infiles, '')
# are input and output lists the same length?
saltio.comparelists(infiles, outfiles, 'Input', 'output')
# does crosstalk coefficient data exist
if usedb:
xtalkfile = xtalkfile.strip()
xdict = saltio.readxtalkcoeff(xtalkfile)
else:
xdict = None
for img, oimg in zip(infiles, outfiles):
#open the fits file
struct = saltio.openfits(img)
#find the best xcoeff for the image if using the db
if usedb:
obsdate = saltkey.get('DATE-OBS', struct[0])
obsdate = int('%s%s%s' %
(obsdate[0:4], obsdate[5:7], obsdate[8:]))
xkey = np.array(xdict.keys())
date = xkey[abs(xkey - obsdate).argmin()]
xcoeff = xdict[date]
else:
xcoeff = []
# identify instrument
instrume, keyprep, keygain, keybias, keyxtalk, keyslot = saltkey.instrumid(
struct)
# has file been prepared already?
if saltkey.found(keyxtalk, struct[0]):
message = '%s has already been xtalk corrected' % img
raise SaltError(message)
#apply the cross-talk correction
struct = xtalk(struct, xcoeff, log=log, verbose=verbose)
# housekeeping keywords
fname, hist = history(level=1,
wrap=False,
exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0], 'SXTALK',
'Images have been xtalk corrected', hist)
# write FITS file
saltio.writefits(struct, oimg, clobber=clobber)
saltio.closefits(struct)
def slot(struct, infile, dbspeed, dbrate, dbgain, dbnoise, dbbias, dbamp,
xcoeff, gaindb, xtalkfile, logfile, verbose):
import saltprint, saltkey, saltio, saltstat, time
# identify instrument
instrume, keyprep, keygain, keybias, keyxtalk, keyslot, status = saltkey.instrumid(
struct, infile, logfile)
# number of image HDU
nextend = 0
while (status == 0):
try:
struct[nextend + 1].header['XTENSION']
nextend += 1
except:
break
nccds, status = saltkey.get('NCCDS', struct[0], infile, logfile)
amplifiers = nccds * 2
if (nextend % (amplifiers) != 0):
message = '\nERROR -- SALTSLOT: Number of image extensions and'
message += 'number of amplifiers are not consistent'
status = saltprint.err(saltlog, message)
status = saltkey.new('NSCIEXT', nextend, 'Number of science extensions',
struct[0], infile, logfile)
status = saltkey.new('NEXTEND', nextend, 'Number of data extensions',
struct[0], infile, logfile)
# check image file and gain database are compatible
if (status == 0):
ngains = len(dbgain)
if (int(max(dbamp)) != amplifiers):
message = '\nERROR -- SALTGSLOT: ' + infile + ' contains ' + str(
amplifiers) + ' amplifiers'
message += ', the gaindb file ' + gaindb + ' contains ' + str(
max(dbamp)) + ' amplifiers'
status = saltprint.err(logfile, message)
# check image file and cross talk database are compatible
if (status == 0):
if (len(xcoeff) - 1 != amplifiers):
message = '\nERROR -- SALTSLOT: ' + infile + ' contains ' + str(
amplifiers) + ' amplifiers'
message += ', the cross talk file ' + xtalkfile + ' contains ' + str(
len(xcoeff) - 1) + ' amplifiers'
status = saltprint.err(logfile, message)
# housekeeping keywords
if (status == 0):
status = saltkey.put('SAL-TLM', time.asctime(time.localtime()),
struct[0], infile, logfile)
status = saltkey.new(keyslot, time.asctime(time.localtime()),
'Data have been cleaned by SALTSLOT', struct[0],
infile, logfile)
# keywords for image extensions
for i in range(nextend):
hdu = i + 1
status = saltkey.new('EXTNAME', 'SCI', 'Extension name', struct[hdu],
infile, logfile)
status = saltkey.new('EXTVER', hdu, 'Extension number', struct[hdu],
infile, logfile)
# log coefficent table
if (status == 0):
message = '%30s %5s %4s %8s' % ('HDU', 'Gain', 'Bias', 'Xtalk')
saltprint.log(logfile,
'\n ---------------------------------------------',
verbose)
saltprint.log(logfile, message, verbose)
saltprint.log(logfile,
' ---------------------------------------------',
verbose)
# loop over image extensions
if (status == 0):
for i in range(nextend / 2):
hdu = i * 2 + 1
amplifier = hdu % amplifiers
if (amplifier == 0): amplifier = amplifiers
if (status == 0):
value, status = saltkey.get('NAXIS1', struct[hdu], infile,
logfile)
naxis1 = int(value)
if (status == 0):
value, status = saltkey.get('NAXIS1', struct[hdu + 1], infile,
logfile)
naxis2 = int(value)
if (status == 0 and hdu == 1):
biassec, status = saltkey.get('BIASSEC', struct[hdu], infile,
logfile)
if (status == 0 and hdu == 1):
ranges = biassec.lstrip('[').rstrip(']').split(',')
x1_1 = int(ranges[0].split(':')[0]) - 1
x2_1 = int(ranges[0].split(':')[1]) - 1
y1_1 = int(ranges[1].split(':')[0]) - 1
y2_1 = int(ranges[1].split(':')[1]) - 1
if (status == 0 and hdu == 1):
biassec, status = saltkey.get('BIASSEC', struct[hdu + 1],
infile, logfile)
if (status == 0 and hdu == 1):
ranges = biassec.lstrip('[').rstrip(']').split(',')
x1_2 = int(ranges[0].split(':')[0]) - 1
x2_2 = int(ranges[0].split(':')[1]) - 1
y1_2 = int(ranges[1].split(':')[0]) - 1
y2_2 = int(ranges[1].split(':')[1]) - 1
if (status == 0 and hdu == 1):
datasec, status = saltkey.get('DATASEC', struct[hdu], infile,
logfile)
if (status == 0 and hdu == 1):
ranges = datasec.lstrip('[').rstrip(']').split(',')
dx1_1 = int(ranges[0].split(':')[0]) - 1
dx2_1 = int(ranges[0].split(':')[1])
dy1_1 = int(ranges[1].split(':')[0]) - 1
dy2_1 = int(ranges[1].split(':')[1])
if (status == 0 and hdu == 1):
datasec, status = saltkey.get('DATASEC', struct[hdu + 1],
infile, logfile)
if (status == 0 and hdu == 1):
ranges = datasec.lstrip('[').rstrip(']').split(',')
dx1_2 = int(ranges[0].split(':')[0]) - 1
dx2_2 = int(ranges[0].split(':')[1])
dy1_2 = int(ranges[1].split(':')[0]) - 1
dy2_2 = int(ranges[1].split(':')[1])
if (status == 0 and dx2_1 - dx1_1 != dx2_2 - dx1_2):
message = 'ERROR -- SALTSLOT: HDUs ' + infile
message += '[' + str(hdu) + '] and ' + infile + '[' + str(
hdu + 1) + ']'
message += ' have different dimensions'
status = saltprint.err(logfile, message)
# read speed and gain of each exposure
if (status == 0 and hdu == 1):
gainset, status = saltkey.get('GAINSET', struct[0], infile,
logfile)
rospeed, status = saltkey.get('ROSPEED', struct[0], infile,
logfile)
if (rospeed == 'NONE'):
saltprint.log(logfile, " ", verbose)
message = "ERROR -- SALTSLOT: Readout speed is 'NONE' in "
message += "primary keywords of " + infile
status = saltprint.err(logfile, message)
# read raw images
if (status == 0):
imagedata1, status = saltio.readimage(struct, hdu, logfile)
imagedata2, status = saltio.readimage(struct, hdu + 1, logfile)
# gain correction
if (status == 0):
for j in range(len(dbgain)):
if (gainset == dbrate[j] and rospeed == dbspeed[j]
and amplifier == int(dbamp[j])):
try:
gain1 = float(dbgain[j])
imagedata1 *= gain1
except:
mesage = 'ERROR -- SALTSLOT: Cannot perform gain correction on image '
message += infile + '[' + str(hdu) + ']'
status = saltprint.err(logfile, message)
elif (gainset == dbrate[j] and rospeed == dbspeed[j]
and amplifier + 1 == int(dbamp[j])):
try:
gain2 = float(dbgain[j])
imagedata2 *= gain2
except:
mesage = 'ERROR -- SALTSLOT: Cannot perform gain correction on image '
message += infile + '[' + str(hdu + 1) + ']'
status = saltprint.err(logfile, message)
# crosstalk correction
if (status == 0):
revimage1 = imagedata1 * float(xcoeff[amplifier])
revimage2 = imagedata2 * float(xcoeff[amplifier + 1])
for j in range(dx2_1 - dx1_1 + 1):
imagedata1[:, j] -= revimage2[:, dx2_2 - j - 1]
imagedata2[:, j] -= revimage1[:, dx2_1 - j - 1]
# bias subtraction
if (status == 0):
overx_val_1 = []
overx_val_2 = []
for x in range(x1_1, x2_1 + 1):
list_1 = imagedata1[y1_1:y2_1, x] * 1.0
overx_val_1.append(saltstat.median(list_1, logfile))
overlevel_1 = saltstat.median(overx_val_1, logfile)
for x in range(x1_2, x2_2 + 1):
list_2 = imagedata2[y1_2:y2_2, x] * 1.0
overx_val_2.append(saltstat.median(list_2, logfile))
overlevel_2 = saltstat.median(overx_val_2, logfile)
imagedata1 -= overlevel_1
imagedata2 -= overlevel_2
# trim overscan
if (status == 0):
imagedata1 = imagedata1[dy1_1:dy2_1, dx1_1:dx2_1]
imagedata2 = imagedata2[dy1_2:dy2_2, dx1_2:dx2_2]
datasec = '[1:' + str(dx2_1 - dx1_1) + ',1:' + str(dy2_1 -
dy1_1) + ']'
status = saltkey.put('DATASEC', datasec, struct[hdu], infile,
logfile)
status = saltkey.rem('BIASSEC', struct[hdu], infile, logfile)
datasec = '[1:' + str(dx2_2 - dx1_2) + ',1:' + str(dy2_2 -
dy1_2) + ']'
status = saltkey.put('DATASEC', datasec, struct[hdu + 1],
infile, logfile)
status = saltkey.rem('BIASSEC', struct[hdu + 1], infile,
logfile)
# log coefficient table
if (status == 0):
infilename = infile.split('/')
infilename = infilename[len(infilename) - 1]
message = '%25s[%3d] %5.2f %4d %8.6f' % \
(infilename, hdu, gain1, overlevel_1, float(xcoeff[amplifier+1]))
saltprint.log(logfile, message, verbose)
message = '%25s[%3d] %5.2f %4d %8.6f' % \
(infilename, hdu+1, gain2, overlevel_2,float(xcoeff[amplifier]))
saltprint.log(logfile, message, verbose)
# update image in HDU structure
if (status == 0):
struct, status = saltio.writeimage(struct, hdu, imagedata1,
logfile)
struct, status = saltio.writeimage(struct, hdu + 1, imagedata2,
logfile)
return struct, status
def saltbias(images,outimages,outpref,subover=True,trim=True,subbias=False,
masterbias='bias.fits', median=False, function='polynomial',
order=3, rej_lo=3, rej_hi=3, niter=10, plotover=False,
turbo=False, clobber=False, logfile='salt.log', verbose=True):
status = 0
ifil = 0
ii = 0
mbiasdata = []
bstruct = ''
biasgn = ''
biassp = ''
biasbn = ''
biasin = ''
filetime = {}
biastime = {}
for i in range(1,7):
filetime[i] = []
biastime[i] = []
with logging(logfile,debug) as log:
# Check the input images
infiles = saltio.argunpack ('Input',images)
# create list of output files
outfiles=saltio.listparse('Outfile', outimages, outpref,infiles,'')
# are input and output lists the same length?
saltio.comparelists(infiles,outfiles,'Input','output')
# Does master bias frame exist?
# gain, speed, binning and instrument of master bias frame
if subbias:
if os.path.isfile(masterbias):
bstruct = saltio.openfits(masterbias)
else:
message = 'Master bias frame %s does not exist' % masterbias
raise SaltError(message)
else:
bstruct=None
# open each raw image file
for img, oimg in zip(infiles, outfiles):
#open the file
struct = saltio.openfits(img)
#check to see if it has already been bias subtracted
instrume,keyprep,keygain,keybias,keyxtalk,keyslot = saltkey.instrumid(struct)
# has file been biaseded already?
try:
key = struct[0].header[keybias]
message = 'File %s has already been de-biased ' % infile
raise SaltError(message)
except:
pass
#compare with the master bias to make sure they are the same
if subbias:
pass
#subtract the bias
struct=bias(struct,subover=subover, trim=trim, subbias=subbias,
bstruct=bstruct, median=median, function=function,
order=order, rej_lo=rej_lo, rej_hi=rej_hi, niter=niter,
plotover=plotover, log=log, verbose=verbose)
#write the file out
# housekeeping keywords
fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
saltkey.housekeeping(struct[0],keybias, 'Images have been de-biased', hist)
# write FITS file
saltio.writefits(struct,oimg, clobber=clobber)
saltio.closefits(struct)
def slotphot(images,outfile,srcfile,newfits=None,phottype='square',
subbacktype='median',sigback=3,mbin=7,sorder=3,niter=5,sigdet=5,
contpix=10,ampperccd=2,ignorexp=6,driftlimit=10.,finddrift=True,
outtype='ascii',reltime=True,clobber=True,logfile='salt.log',
verbose=True):
"""Perform photometry on listed SALT slotmode *images*."""
with logging(logfile,debug) as log:
# set up the variables
entries = []
vig_lo = {}
vig_hi = {}
amp = {}
x = {}
y = {}
x_o = {}
y_o = {}
r = {}
br1 = {}
br2 = {}
hour = 0
min = 0
sec = 0.
time0 = 0.
nframes = 0
bin=mbin
order=sorder
# is the input file specified?
saltsafeio.filedefined('Input',images)
# if the input file is a list, does it exist?
if images[0] == '@':
saltsafeio.listexists('Input',images)
# parse list of input files
infiles=saltsafeio.listparse('Raw image',images,'','','')
# check input files exist
saltsafeio.filesexist(infiles,'','r')
# is the output file specified?
saltsafeio.filedefined('Output',outfile)
# check output file does not exist, optionally remove it if it does exist
if os.path.exists(outfile) and clobber:
os.remove(outfile)
elif os.path.exists(outfile) and not clobber:
raise SaltIOError('File '+outfile+' already exists, use clobber=y')
# open output ascii file
if outtype=='ascii':
try:
lc = open(outfile,'a')
except:
raise SaltIOError('Cannot open ouput file '+outfile)
# is the extraction region defintion file specified?
saltsafeio.filedefined('Extraction region defintion',srcfile)
# check extraction region defintion file exists
srcfile = srcfile.strip()
saltsafeio.fileexists(srcfile)
# read extraction region defintion file
amp, x, y, x_o, y_o, r, br1, br2=slottool.readsrcfile(srcfile)
# set the writenewfits parameter
if not newfits or newfits=='none':
writenewfits=False
else:
writenewfits=newfits
# get time of first exposure and basic information about the observations
infile=infiles[0]
struct=saltsafeio.openfits(infile)
# identify instrument
instrume,keyprep,keygain,keybias,keyxtalk,keyslot=saltsafekey.instrumid(struct,infile)
# how many extensions?
nextend=saltsafekey.get('NEXTEND',struct[0],infile)
if nextend < amp['comparison']:
msg='Insufficient number of extensions in %s' % (infile)
raise SaltIOError(msg)
# how many amplifiers?
amplifiers=saltsafekey.get('NCCDS',struct[0],infile)
amplifiers = int(ampperccd*float(amplifiers))
if ampperccd>0:
nframes = int(nextend/amplifiers)
nstep=amplifiers
else:
nframes = nextend
nstep=1
ntotal=nframes*len(infiles)
# image size
naxis1=saltsafekey.get('NAXIS1',struct[amp['comparison']],infile)
naxis2=saltsafekey.get('NAXIS2',struct[amp['comparison']],infile)
# CCD binning
ccdsum=saltsafekey.get('CCDSUM',struct[0],infile)
binx=int(ccdsum.split(' ')[0])
biny=int(ccdsum.split(' ')[1])
# Identify the time of the observations
ext = 1
try:
time0=slottool.getobstime(struct[ext], infile+'['+str(ext)+']')
dateobs=saltsafekey.get('DATE-OBS',struct[ext],infile)
dateobs=dateobs.replace('-','/')
except:
raise SaltIOError('No time or obsdate in first image')
# If a total file is to be written out, create it and update it
if writenewfits:
if os.path.isfile(writenewfits):
if clobber:
saltsafeio.delete(writenewfits)
else:
raise SaltIOError('Newfits file exists, use clobber')
try:
hdu=pyfits.PrimaryHDU()
hdu.header=struct[0].header
hdu.header['NCCDS']=1
hdu.header['NSCIEXT']=ntotal-ignorexp
hdu.header['NEXTEND']=ntotal-ignorexp
hduList=pyfits.HDUList(hdu)
hduList.verify()
hduList.writeto(writenewfits)
except:
raise SaltIOError('Could not create newfits file, '+writenewfits)
# Close image file
saltsafeio.closefits(struct)
# Read newfits file back in for updating
if writenewfits:
try:
hduList=pyfits.open(writenewfits,mode='update')
except:
raise SaltIOError('Cannot open newfits file '+writenewfits+' for updating.')
# set up the arrays
j=0
time=np.zeros(ntotal ,dtype='float')-1.0
dx=np.zeros(ntotal ,dtype='float')
dy=np.zeros(ntotal ,dtype='float')
tflux=np.zeros(ntotal ,dtype='float')
terr =np.zeros(ntotal ,dtype='float')
cflux=np.zeros(ntotal ,dtype='float')
cerr =np.zeros(ntotal ,dtype='float')
ratio=np.zeros(ntotal ,dtype='float')
rerr =np.zeros(ntotal ,dtype='float')
tgt_x=np.zeros(ntotal ,dtype='float')
tgt_y=np.zeros(ntotal ,dtype='float')
cmp_x=np.zeros(ntotal ,dtype='float')
cmp_y=np.zeros(ntotal ,dtype='float')
p_one=100./ntotal # One percent
p_old=-1 # Previous completed percentage
p_new=0 # New completed percentage
p_n=1 # Counter number
for infile in infiles:
# Log
if verbose:
log.message('Starting photometry on file '+infile, with_stdout=False)
struct=pyfits.open(infile)
# Skip through the frames and process each frame individually
for i in range(nframes):
# Show progress
if verbose:
p_new=int(p_n*p_one)
p_n+=1
if p_new!=p_old:
ctext='Percentage Complete: %d\r' % p_new
sys.stdout.write(ctext)
sys.stdout.flush()
p_old=p_new
if not (infile==infiles[0] and i < ignorexp):
ext=amp['comparison']+i*nstep
try:
header=struct[ext].header
array=struct[ext].data
array=array*1.0
except:
msg='Unable to open extension %i in image %s' % (ext, infile)
raise SaltIOError(msg)
# starti the analysis of each frame
# get the time
time[j]=slottool.getobstime(struct[ext],infile+'['+str(ext)+']')
# gain and readout noise
try:
gain=float(header['GAIN'])
except:
gain=1
raise SaltIOError('Gain not specified in image header')
try:
rdnoise=float(header['RDNOISE'])
except:
rdnoise=0
raise SaltIOError('RDNOISE not specified in image header')
# background subtraction
if not subbacktype=='none':
try:
array=subbackground(array, sigback, bin, order, niter, subbacktype)
except SaltError:
log.warning('Image '+infile+' extention '+str(ext)+' is blank, skipping')
continue
# x-y fit to the comparison star and update the x,y values
if finddrift:
carray, fx,fy=slottool.finddrift(array, x['comparison'], y['comparison'], r['comparison'], naxis1, naxis2, sigdet, contpix, sigback, driftlimit, niter)
if fx > -1 and fy > -1:
if fx < naxis1 and fy < naxis2:
dx[j]=x['comparison']-fx
dy[j]=y['comparison']-fy
x['comparison']=fx
y['comparison']=fy
x['target']=x['target']-dx[j]
y['target']=y['target']-dy[j]
else:
dx[j]=0
dy[j]=0
x['comparison']=x_o['comparison']
y['comparison']=y_o['comparison']
x['target']=x_o['target']
y['target']=y_o['target']
else:
msg='No comparison object found in image file ' + infile+' on extension %i skipping.' % ext
log.warning(msg)
pass
# do photometry
try:
tflux[j],terr[j],cflux[j],cerr[j],ratio[j],rerr[j]=slottool.dophot(phottype, array, x, y, r, br1, br2, gain, rdnoise, naxis1, naxis2)
except SaltError, e:
msg='Could not do photometry on extension %i in image %s because %s skipping.' % (ext, infile, e)
log.warning(msg)
tgt_x[j]=x['target']
tgt_y[j]=y['target']
cmp_x[j]=x['comparison']
cmp_y[j]=y['comparison']
# record results
# TODO! This should be removed in favor of the write all to disk in the end
if outtype=='ascii':
slottool.writedataout(lc, j+1, time[j], x, y, tflux[j], terr[j], cflux[j],cerr[j],ratio[j],rerr[j],time0, reltime)
# write newfits file
if writenewfits:
# add original name and extension number to header
try:
hdue=pyfits.ImageHDU(array)
hdue.header=header
hdue.header.update('ONAME',infile,'Original image name')
hdue.header.update('OEXT',ext,'Original extension number')
hduList.append(hdue)
except:
log.warning('Could not update image in newfits '+infile+' '+str(ext))
# increment counter
j+=1
# close FITS file
saltsafeio.closefits(struct)
# close newfits file
if writenewfits:
try:
hduList.flush()
hduList.close()
except:
raise SaltIOError('Cannot close newfits file.')
# write to output
if outtype=='ascii':
# close output ascii file
try:
lc.close()
except:
raise SaltIOError('Cannot close ouput file ' + outfile)
elif outtype=='fits':
print 'writing fits'
try:
c1=pyfits.Column(name='index',format='D',array=np.arange(ntotal))
if reltime:
c2=pyfits.Column(name='time',format='D',array=time-time0)
else:
c2=pyfits.Column(name='time',format='D',array=time)
c3=pyfits.Column(name='tgt_x',format='D',array=tgt_x)
c4=pyfits.Column(name='tgt_y',format='D',array=tgt_y)
c5=pyfits.Column(name='tgt_flux',format='D',array=tflux)
c6=pyfits.Column(name='tgt_err',format='D',array=terr)
c7=pyfits.Column(name='cmp_x',format='D',array=cmp_x)
c8=pyfits.Column(name='cmp_y',format='D',array=cmp_y)
c9=pyfits.Column(name='cmp_flux',format='D',array=cflux)
c10=pyfits.Column(name='cmp_err',format='D',array=cerr)
c11=pyfits.Column(name='flux_ratio',format='D',array=ratio)
c12=pyfits.Column(name='flux_ratio_err',format='D',array=rerr)
tbhdu=pyfits.new_table([c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12])
# Add header information
tbhdu.header.update('RELTIME',str(reltime),'Time relative to first datapoint or absolute.')
tbhdu.writeto(outfile)
print 'fits written to ',outfile
except:
raise SaltIOError('Could not write to fits table.')