def hrsstack(images, outimages, outpref, clobber=True, logfile='salt.log',verbose=True):
    """Convert MEF HRS data into a single image.  If variance frames and BPMs, then 
       convert them to the same format as well.   Returns an MEF image but that is
       combined into a single frame

    """
 
    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 file and write out as a fits files in the output directory
       for img,oimg in zip(infiles, outfiles):
          hdu=saltio.openfits(img)
          hdu=stack(hdu)
          log.message('Stacking HRS %s to %s' % (img, oimg), with_header=False)
          saltio.writefits(hdu, oimg, clobber=clobber)
    
 
    return 

def saltobslog(images,outfile,clobber=False,logfile='salt.log',verbose=True):
  """Create the observation log from the input files"""

  #start the logging
  with logging(logfile,debug) as log:

       # Check the input images 
       infiles = saltio.argunpack ('Input',images)


       #create the header dictionary
       headerDict=obslog(infiles, log)

       #clobber the output if it exists
       if (clobber and os.path.isfile(outfile)):
           saltio.delete(outfile)

       #create the fits file
       struct=createobslogfits(headerDict)

       # close table file
       saltio.writefits(struct, outfile)

       #indicate the log was created
       log.message('\nSALTLOG -- created observation log ' + outfile)

def hrsprepare(images, outimages, outpref, clobber=True, logfile='salt.log',verbose=True):
    """Convert .fit files to .fits files and place HRS data into 
       standard SALT FITS format

    """
 
    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 file and write out as a fits files in the output directory
       for img,oimg in zip(infiles, outfiles):
          hdu=saltio.openfits(img)
          hdu=prepare(hdu)
          log.message('Preparing HRS %s to %s' % (img, oimg), with_header=False)
          saltio.writefits(hdu, oimg, clobber=clobber)
    
 
    return 

def specselfid(images, outimages, outpref, refimage=None, ystart='middlerow',
               rstep=3, clobber=False, logfile='salt.log', verbose=True):

    with logging(logfile, debug) as log:

        # set up the variables
        infiles = []
        outfiles = []

        # Check the input images
        infiles = saltio.argunpack('Input', images)

        # create list of output files
        outfiles = saltio.listparse(
            'Outimages',
            outimages,
            outpref,
            infiles,
            '')

        # set up defaults
        if saltio.checkfornone(refimage) is not None:
            rhdu = saltio.openfits(refimage)
        else:
            refimage = None

        # read in rectify each image
        for img, oimg, in zip(infiles, outfiles):
            hdu = saltio.openfits(img)
            log.message(
                'Performing self-identification and rectification on %s' %
                img)
            for i in range(1, len(hdu)):
                if hdu[i].name == 'SCI':
                    if refimage is None:
                        sdata = hdu[i].data
                    else:
                        sdata = rhdu[i].data
                    hdu[i].data = selfid(
                        hdu[i].data,
                        sdata,
                        ystart=ystart,
                        rstep=rstep)
                    if saltkey.found('VAREXT', hdu[i]):
                        varext = saltkey.get('VAREXT', hdu[i])
                        hdu[varext].data = selfid(
                            hdu[varext].data,
                            sdata,
                            ystart=ystart,
                            rstep=rstep)
                    if saltkey.found('BPMEXT', hdu[i]):
                        bpmext = saltkey.get('BPMEXT', hdu[i])
                        hdu[bpmext].data = selfid(
                            hdu[bpmext].data,
                            sdata,
                            ystart=ystart,
                            rstep=rstep)

            # write out the oimg
            saltio.writefits(hdu, oimg, clobber=clobber)

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 saltsurface(images,outimages,outpref, mask=True,  order=3, minlevel=0,
             clobber=False, 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 each raw image file
       for infile, outfile in zip(infiles,outfiles):
           struct = saltio.openfits(infile)

           
           struct = surface_fit(struct, order=order, mask=mask, minlevel=minlevel)

           #add any header keywords like history 
           fname, hist=history(level=1, wrap=False)
           saltkey.housekeeping(struct[0],'SURFIT', 'File fit by a surface', hist)

           #write it out and close it
           saltio.writefits(struct,outfile,clobber=clobber)
           saltio.closefits(struct)

           #output the information
           log.message('Surface fitted image %s ' % (infile), with_header=False, with_stdout=verbose)

def saltcombine(images,outimage, method='average', reject=None, mask=True,     \
                weight=True, blank=0, scale=None, statsec=None, lthresh=3,    \
                hthresh=3, clobber=False, logfile='salt.log',verbose=True):

   with logging(logfile,debug) as log:

       # Check the input images 
       infiles = saltio.argunpack ('Input',images)

       #set reject as None
       reject=saltio.checkfornone(reject)
       if reject is not None: reject=reject.lower()

       #set scale 
       scale=saltio.checkfornone(scale)
       if scale is not None: scale=scale.lower()

       #set statsec
       statsec=saltio.checkfornone(statsec)
       statsec=saltio.getSection(statsec, iraf_format=True)

       #Fast combine the images
       outstruct=imcombine(infiles, method=method, reject=reject, mask=mask, \
                           weight=weight, blank=blank, scale=scale,          \
                           statsec=statsec, lthresh=lthresh, hthresh=hthresh)

       # housekeeping keywords
       fname, hist=history(level=1, wrap=False)
       saltkey.housekeeping(outstruct[0],'SCOMBINE', 'File Combined by SALTCOMBINE', hist)

       # write FITS file               
       saltio.writefits(outstruct, outimage)

def saltillum(images, outimages, outpref, mbox=11, clobber=False, 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 each raw image file
        for infile, outfile in zip(infiles, outfiles):
            struct = saltio.openfits(infile)

            struct = illum_cor(struct, mbox)

            # add any header keywords like history
            fname, hist = history(level=1, wrap=False)
            saltkey.housekeeping(struct[0], "SILLUM", "File Illumination corrected", hist)

            # write it out and close it
            saltio.writefits(struct, outfile, clobber=clobber)
            saltio.closefits(struct)

            # output the information
            log.message("Illumination corrected image %s " % (infile), with_header=False, with_stdout=verbose)

def saltfpskyring(
    images,
    outimages,
    outpref,
    axc,
    ayc,
    arad,
    rxc,
    ryc,
    pmin,
    pmax,
    swindow=5,
    clobber=False,
    logfile="salt.log",
    verbose=True,
):
    """Sky subtracts Fabry-Perot images"""

    # start log now that all parameter are set up

    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")

        for img, oimg in zip(infiles, outfiles):

            # open up the file
            hdu = saltio.openfits(img)

            # determine the azimuthally averaged profile
            rpro, radial_profile = median_radial_profile(
                hdu[0].data, xc=axc, yc=ayc, rmax=arad, nbins=100, pmin=pmin, pmax=pmax
            )

            if swindow > 1:
                radial_profile = np.convolve(radial_profile, np.ones(swindow), mode="same") / swindow

            # calculate the indices from the image
            y, x = np.indices(hdu[0].data.shape)
            radius = np.hypot(x - axc, y - ayc)

            # subtract off the sky data
            mdata = hdu[0].data - np.interp(radius, rpro, radial_profile)
            hdu[0].data = mdata

            # write FITS file
            saltio.writefits(hdu, oimg, clobber=clobber)
            saltio.closefits(hdu)

            message = "SALTFPSKYRING -- Subtracted sky from  %s" % (img)
            log.message(message, with_header=False)

def saltcrclean(images,outimages,outpref,crtype='fast',thresh=5,mbox=3,         \
                bthresh=3, flux_ratio=0.2, bbox=11, gain=1, rdnoise=5, fthresh=5,\
                bfactor=2, gbox=3, maxiter=5, multithread=False, update=True,
                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')

       #check to see if multithreading is available
       if mp:
          pass
       else:
          multithread=False
          log.warning('multiprocessing module is not available.  Setting multiththread=False')


       # Begin processes each file
       for infile,outfile in zip(infiles,outfiles):

           #open the infile
           struct=saltio.openfits(infile)

           #clean the cosmic rays
           if multithread and len(struct)>1:
               struct=multicrclean(struct, crtype, thresh, mbox, bbox, bthresh, flux_ratio, \
                          gain, rdnoise, bfactor, fthresh, gbox, maxiter, log, verbose=verbose)
           else:
               struct=crclean(struct, crtype, thresh, mbox, bbox, bthresh, flux_ratio, \
                          gain, rdnoise, bfactor, fthresh, gbox, maxiter, update, log, verbose=verbose)
          
           #log the call
           #log.message('Cleaned %i cosmic rays from %s using %s method' % (totcr, infile, crtype), with_header=False)
           log.message('', with_header=False, with_stdout=verbose)

           #add house keeping keywords
           saltkey.put('SAL-TLM',time.asctime(time.localtime()), struct[0])
   
           #add the history keyword
           fname, hist=history(level=1, wrap=False)
           saltkey.history(struct[0],hist)

           #write out the file
           saltio.writefits(struct, outfile, clobber=clobber)

           #close the image
           saltio.closefits(struct)

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 specwavemap(
    images,
    outimages,
    outpref,
    solfile=None,
    caltype="line",
    function="polynomial",
    order=3,
    blank=0,
    nearest=False,
    clobber=True,
    logfile="salt.log",
    verbose=True,
):

    with logging(logfile, debug) as log:

        # set up the variables
        infiles = []
        outfiles = []

        # Check the input images
        infiles = saltsafeio.argunpack("Input", images)

        # create list of output files
        outfiles = saltsafeio.listparse("Outimages", outimages, outpref, infiles, "")

        # read in the wavelength solutions and enter them into
        # there own format
        if caltype == "line":
            soldict = sr.entersolution(solfile)
        else:
            soldict = None

        # read in rectify each image
        for img, oimg in zip(infiles, outfiles):
            if caltype == "line":
                msg = "Creating wave map image %s from image %s using files %s" % (oimg, img, solfile)
            else:
                msg = "Creating wave map image %s from image %s using RSS Model" % (oimg, img)
            log.message(msg)
            hdu = saltsafeio.openfits(img)
            hdu = wavemap(
                hdu,
                soldict,
                caltype=caltype,
                function=function,
                order=order,
                blank=blank,
                nearest=nearest,
                clobber=clobber,
                log=log,
                verbose=verbose,
            )
            saltsafeio.writefits(hdu, oimg, clobber=clobber)

def saltarith(operand1, op, operand2, result, outpref, divzero=0, clobber=False,     \
             logfile='salt.log',verbose=True):


   with logging(logfile,debug) as log:

       # Check the input images 
       infiles = saltio.argunpack ('Input',operand1)

       # create list of output files 
       outfiles=saltio.listparse('Outfile', result, outpref, infiles,'')

       #verify that the input and output lists are the same length
       saltio.comparelists(infiles,outfiles,'Input','output')

       #let's keep track of whether operand2 is an image or not
       is_image = False

       #load in operand2, or, if it's not an image, assume it's a number
       try: operand2struct = float(operand2)
       except ValueError:
          operand2struct = saltio.openfits(operand2)
          is_image = True

       #open the input image files
       for infile, outfile in zip(infiles,outfiles):
           struct = saltio.openfits(infile)

           #do some math!
           outstruct = arith(struct, op, operand2struct, is_image, divzero)
           try:
               pass 
           except Exception as e:
               msg='Unable to do math %s because %s' % (infile, e)
               raise SaltError(msg)

           #update header stuff
           fname, hist = history(level=1, wrap=False)
           saltkey.housekeeping(struct[0],'SARITH', 'Some arithmatic was performed',hist)

           #write it. close it.
           saltio.writefits(outstruct,outfile,clobber=clobber)
           saltio.closefits(struct)

           #output the information
           log.message('imarith: %s %s %s %s' % (infile, op, operand2, outfile), with_header=False, with_stdout=verbose)

       #close the operand2 image
       if is_image: saltio.closefits(operand2struct)

def saltmosaic(images,outimages,outpref,geomfile,interp='linear',geotran=True, cleanup=True,clobber=False,logfile=None,verbose=True):

   #Start the 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')



       # does CCD geometry definition file exist
       geomfilefile = geomfile.strip()
       saltio.fileexists(geomfile)

       gap = 0
       xshift = [0, 0]
       yshift = [0, 0]
       rotation = [0, 0]
       gap, xshift, yshift, rotation=saltio.readccdgeom(geomfile)

       # open each raw image file and apply the transformation to it
       for img, oimg in zip(infiles, outfiles):

           #open the structure
           struct = saltio.openfits(img)

           #create the mosaic
           ostruct=make_mosaic(struct, gap, xshift, yshift, rotation, interp_type=interp, geotran=geotran, cleanup=cleanup, log=log, verbose=verbose)

           #update the header information
           # housekeeping keywords
           fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
           saltkey.housekeeping(ostruct[0], 'SMOSAIC', 'Images have been mosaicked ', hist)

           #write the image out
           saltio.writefits(ostruct,oimg, clobber=clobber)
 
           #close the files
           saltio.closefits(struct)
           saltio.closefits(ostruct)

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 specrectify(images, outimages, outpref, solfile=None, caltype='line',
                function='polynomial', order=3, inttype='linear', w1=None,
                w2=None, dw=None, nw=None, blank=0, conserve=False, nearest=False,
                clobber=True, logfile='salt.log', verbose=True):

    with logging(logfile, debug) as log:

        # set up the variables
        infiles = []
        outfiles = []

        # Check the input images
        infiles = saltsafeio.argunpack('Input', images)

        # create list of output files
        outfiles = saltsafeio.listparse(
            'Outimages',
            outimages,
            outpref,
            infiles,
            '')

        # read in the wavelength solutions and enter them into
        # there own format
        if caltype == 'line':
            soldict = entersolution(solfile)
        else:
            soldict = None

        # read in rectify each image
        for img, oimg, in zip(infiles, outfiles):
            if caltype == 'line':
                msg = 'Creating rectified image %s from image %s using files %s' % (
                    oimg, img, solfile)
            else:
                msg = 'Creating rectified image %s from image %s using RSS Model' % (
                    oimg, img)
            log.message(msg)
            hdu = saltsafeio.openfits(img)
            hdu = rectify(hdu, soldict, caltype=caltype, function=function,
                          order=order, inttype=inttype, w1=w1, w2=w2, dw=dw, nw=nw,
                          pixscale=0.0, blank=blank, conserve=conserve, nearest=nearest,
                          clobber=clobber, log=log, verbose=verbose)
            # write out the oimg
            saltsafeio.writefits(hdu, oimg, clobber=clobber)

def createrecord(recfile, fitcol, keycol, oldcol, newcol, clobber):
   """Create the fits table record of all of the changes that were made"""

   col1 = fits.Column(name='FILE',format='32A',array=fitcol)
   col2 = fits.Column(name='KEYWD',format='8A',array=keycol)
   col3 = fits.Column(name='OLD_VAL',format='24A',array=oldcol)
   col4 = fits.Column(name='NEW_VAL',format='24A',array=newcol)
   cols = fits.ColDefs([col1,col2,col3,col4])
   rectable = fits.BinTableHDU.from_columns(cols)

   #add some additional keywords
   saltkey.new('EXTNAME','NEWKEYS','Name of this binary table extension', rectable)
   saltkey.new('OBSERVAT','SALT','South African Large Telescope', rectable)
   saltkey.new('SAL-TLM',time.asctime(time.localtime()), 'File last updated by PySALT tools',rectable)
   saltkey.new('SAL-EDT',time.asctime(time.localtime()), 'Keywords updated by SALTEDTKY',rectable)

   #write it out
   saltio.writefits(rectable, recfile, clobber)

def slotreadtimefix(images,outimages, outpref, 
                    clobber=False, logfile='slot.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')

       for img, oimg in zip(infiles, outfiles):
           #check to see if the out image already exists
           if not clobber and os.path.isfile(oimg):
              raise SaltIOError('%s alraedy exists' % oimg)

           #open the file
           struct=saltio.openfits(img)

           #log the message
           log.message('Updateing times in %s' % img, with_header=False, with_stdout=verbose)

           #now for each science frame, corrent the readtime
           #Assumes SALT format and that the first extension 
           #is empty
           for i in range(1,len(struct)):
              try:
                  struct[i]=readtimefix(struct[i])
              except SaltIOError,e :
                  raise SaltError('%s %s' % (img,e))

           #Add history keywords
           # housekeeping keywords
           fname, hist=history(level=1, wrap=False, exclude=['images', 'outimages', 'outpref'])
           saltkey.housekeeping(struct[0],"SLOTREAD", 'READTIME added', hist)


           #write to the output
           saltio.writefits(struct, oimg, clobber)

       return

def convertsalt(img, oimg, ext=1, clobber=True):
   """Convert a SALT MEF file into a single extension fits file"""

   #open the image
   hdu=saltio.openfits(img)

   #if len one, copy and return
   if len(hdu)==1:  
      hdu.writeto(oimg)
      return

   #create the new output image
   odu = pyfits.PrimaryHDU(data=hdu[ext].data, header=hdu[0].header)

   #combine the headers from the primary and first exention
   for c in hdu[ext].header.ascardlist(): odu.header.update(c.key, c.value, c.comment)

   #write the data out
   saltio.writefits(odu, oimg, clobber=clobber)