def specidentify(images,linelist, outfile, guesstype, guessfile, function, \ order, rstep, interact, clobber,logfile,verbose,status): with logging(logfile,debug) as log: #set up the variables infiles = [] outfiles = [] status = 0 # Check the input images infiles = saltsafeio.argunpack ('Input',images) # create list of output files outfiles = saltsafeio.argunpack ('Input',outfile) #if outfiles is a single image, turn it into a list #of the same length as infiles if len(outfiles)!=len(infiles): if len(outfiles)==1: outfiles=outfiles*len(infiles) elif len(outfiles)==0: outfiles=[None]*len(infiles) else: msg='Please enter an appropriate number of outfiles' raise SALTSpecError(msg) # open the line lists slines, sfluxes = readlinelist(linelist) # Identify the lines in each file for img, oimg in zip(infiles, outfiles): identify(img, oimg, slines, sfluxes, guesstype, guessfile, function, order, rstep, interact, clobber, verbose)
def specidentify(images, linelist, outfile, guesstype, guessfile, function, order, rstep, interact, clobber, logfile, verbose, status): with logging(logfile, debug) as log: # set up the variables infiles = [] outfiles = [] # Check the input images infiles = saltsafeio.argunpack('Input', images) print(infiles) # create list of output files outfiles = saltsafeio.argunpack('Input', outfile) # if outfiles is a single image, turn it into a list # of the same length as infiles if len(outfiles) != len(infiles): if len(outfiles) == 1: outfiles = outfiles * len(infiles) elif len(outfiles) == 0: outfiles = [None] * len(infiles) else: msg = 'Please enter an appropriate number of outfiles' raise SALTSpecError(msg) # open the line lists slines, sfluxes = st.readlinelist(linelist) # Identify the lines in each file for img, oimg in zip(infiles, outfiles): log.message('Proccessing image %s' % img) identify(img, oimg, slines, sfluxes, guesstype, guessfile, function, order, rstep, interact, clobber, log, verbose)
def specextract(images, outfile, method='normal', section=None, thresh=3.0, minsize=3.0, outformat='ascii', ext=1, convert=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.argunpack('outfile', outfile) if method is 'weighted': msg = 'This mode is not supported yet' raise SALTSpecError(msg) section = saltio.checkfornone(section) if section is not None: sections = saltio.getSection(section, iraf_format=False) section = [] for i in range(0, len(sections), 2): section.append((sections[i], sections[i + 1])) # Identify the lines in each file for img, ofile in zip(infiles, outfiles): log.message('\nExtracting spectrum in image %s to %s' % (img, ofile), with_header=False, with_stdout=verbose) # open the images hdu = saltio.openfits(img) ap_list = extract(hdu, ext=ext, method=method, section=section, minsize=minsize, thresh=thresh, convert=convert) # write the spectra out if ap_list: write_extract(ofile.strip(), ap_list, outformat=outformat, clobber=clobber) log.message('', with_header=False, with_stdout=verbose)
def specextract( images, outfile, method="normal", section=None, thresh=3.0, minsize=3.0, outformat="ascii", ext=1, convert=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.argunpack("outfile", outfile) if method is "weighted": msg = "This mode is not supported yet" raise SALTSpecError(msg) section = saltio.checkfornone(section) if section is not None: sections = saltio.getSection(section, iraf_format=False) section = [] for i in range(0, len(sections), 2): section.append((sections[i], sections[i + 1])) # Identify the lines in each file for img, ofile in zip(infiles, outfiles): log.message( "\nExtracting spectrum in image %s to %s" % (img, ofile), with_header=False, with_stdout=verbose ) # open the images hdu = saltio.openfits(img) ap_list = extract( hdu, ext=ext, method=method, section=section, minsize=minsize, thresh=thresh, convert=convert ) # write the spectra out if ap_list: write_extract(ofile.strip(), ap_list, outformat=outformat, clobber=clobber) log.message("", with_header=False, with_stdout=verbose)
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 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 salt2iraf(images, outimages, outpref, ext=1, 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') for img, oimg in zip(infiles, outfiles): message = "SALT2IRAF--Converting %s to %s" % (img, oimg) log.message(message, with_header=False) try: convertsalt(img, oimg, ext=ext, clobber=clobber) except SaltError, e: log.message('%s' % e)
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 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 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 specsky(images,outimages,outpref, method='normal', section=None, function='polynomial', order=2, 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,'') if method not in ['normal', 'fit']: msg='%s mode is not supported yet' % method raise SALTSpecError(msg) if section is None: section=saltio.getSection(section) msg='This mode is not supported yet' raise SALTSpecError(msg) else: section=saltio.getSection(section) # Identify the lines in each file for img, ofile in zip(infiles, outfiles): log.message('Subtracting sky spectrum in image %s into %s' % (img, ofile)) #open the images hdu=saltio.openfits(img) #sky subtract the array hdu=skysubtract(hdu, method=method, section=section, funct=function, order=order) #write out the image if clobber and os.path.isfile(ofile): saltio.delete(ofile) hdu.writeto(ofile)
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 bvitftp(propcode, obsdate, sdbhost,sdbname,sdbuser, password, server,username,sender, bcc, emailfile, notify=False, clobber=True,logfile='salt.log',verbose=True): # set up proposers = [] propids = [] pids = [] with logging(logfile,debug) as log: # are the arguments defined if propcode.strip().upper()=='ALL': pids=getbvitproposalcodes(str(obsdate)) else: pids = saltio.argunpack('propcode',propcode) if len(pids)==0: #throw a warning adn exit if not data needs to be filterd log.warning('No data to distribute\n', with_stdout=verbose) return #log into the database sdb=saltmysql.connectdb(sdbhost,sdbname,sdbuser,password) # check PI directories exist ftpdir='/salt/ftparea/' for datapath in pids: pid=os.path.basename(datapath) movebvitdata(pid, datapath, ftpdir, obsdate, sdb, clobber) if notify: notifybvituser(sdb, pid, obsdate, server,username,password,sender, bcc, emailfile)
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 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 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 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 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 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 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 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 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 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 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, 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 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 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 specsky(images, outimages, outpref, method='normal', section=None, function='polynomial', order=2, 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, '') if method not in ['normal', 'fit']: msg = '%s mode is not supported yet' % method raise SALTSpecError(msg) if section is None: section = saltio.getSection(section) msg = 'This mode is not supported yet' raise SALTSpecError(msg) else: section = saltio.getSection(section) # Identify the lines in each file for img, ofile in zip(infiles, outfiles): log.message('Subtracting sky spectrum in image %s into %s' % (img, ofile)) # open the images hdu = saltio.openfits(img) # sky subtract the array hdu = skysubtract(hdu, method=method, section=section, funct=function, order=order) # write out the image if clobber and os.path.isfile(ofile): saltio.delete(ofile) hdu.writeto(ofile)
def saltsdbloadfits(images, sdbhost, sdbname, sdbuser, password, logfile, verbose): """Upload data about images (which is either a fits file, or specificied by @list) to the science data base, sdb """ with logging(logfile,debug) as log: #open up the infiles infiles = saltio.argunpack('Input',images) sdb=saltmysql.connectdb(sdbhost,sdbname,sdbuser,password) for infile in infiles: sdbloadfits(infile, sdb, log, verbose)
def saltfpcalring(images,outfile, waves, method=None, thresh=5, minsize=10, niter=3, conv=0.05, axc=None, ayc=None, clobber=False,logfile='salt.log',verbose=True): """Fits rings in Fabry-Perot ring images""" with logging(logfile,debug) as log: # Check the input images infiles = saltio.argunpack ('Input',images) # if the outfile exists and not clobber, fail saltio.overwrite(outfile,clobber) #open the output file fout = saltio.openascii(outfile, 'w') #make sure that the list of waves is convertable to a numpy array #convert to floats in case the wave is given as a string if isinstance(waves, str): waves=[float(x) for x in waves.split(',')] try: waves=np.array(waves) except: raise SaltError('%s is not convertable to a numpy array' % waves) #check the value of method method=saltio.checkfornone(method) #setup the output file fout.write('#Comment\n') fout.write('# radius err xc yc z ut wave dn file\n') # open each image and detect the ring for img,w in zip(infiles, waves): #open the image hdu=saltio.openfits(img) #measure the ring in each file xc, yc, radius, err, z, ut=make_calring(hdu, method=method, thresh=thresh, niter=niter, conv=conv, minsize=minsize, axc=axc, ayc=ayc) #output the results outstr=' %7.2f %6.2f %7.2f %7.2f %6.2f %7.4f %8.3f 0 %s\n' % (radius, err, xc, yc, z, ut, w, img) fout.write(outstr) log.message(outstr.strip(), with_stdout=verbose, with_header=False) fout.close()
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 saltemail(propcode, obsdate,readme,server='mail.saao.ac.za',username='', password='', bcc='',sdbhost='sdb.saao',sdbname='sdb',sdbuser='******', logfile='salt.log',verbose=True): """For a given date, look into the database for observations made on that date. If propcode='all' send an email to all of the PIs that had data taken on that date. If propcode gives a specific proposal, only send emails to that PI. """ # set up sender = '*****@*****.**' bcclist = bcc.split(',') date_obss = [] propids = [] pis = [] pids = [] email = [] with logging(logfile,debug) as log: #set up the proposal list pids = saltio.argunpack('propcode',propcode) #check to see if the argument is defined saltio.argdefined('obsdate',obsdate) # check readme file exists saltio.fileexists(readme) #connect to the email server try: smtp = smtplib.SMTP() smtp.connect(server) smtp.ehlo() smtp.starttls() smtp.ehlo() except Exception, e: message = 'Cannot connect to %s because %s' % (server, e) log.error(message) try: smtp.login(username,password) except Exception, e: message = 'Cannot login to %s as %s because %s' % (server, username, e) log.error(message)
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 saltfpmask(images, outimages, outpref, axc,ayc, arad, maskmethod='c', maskvalue=0, \ radi=None,rado=None,clobber=False, logfile='saltfp.log', verbose=True): """Aperture masks Fabry-Perot images""" 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 the image hdu = saltio.openfits(img) #test that the data are in the first try: data = hdu[0].data except Exception, e: message = 'SALTFPMASK--ERROR: Could not access data in Primary exention of %s because %s' % ( img, e) log.message(message) #determine the mask value if it is a region if maskmethod == 'region': maskvalue = calc_maskvalue(data, axc, ayc, radi, rado) #mask the image message = "SALTFPMASK--Masking image %s with a value of %s" % ( img, maskvalue) log.message(message, with_header=False) hdu[0].data = maskimage(data, axc, ayc, arad, maskvalue) try: pass except Exception, e: message = 'SALTFPMASK--ERROR: Could not create mask for %s because %s' % ( img, e) log.message(message) #write out the image saltio.writefits(hdu, oimg, clobber=clobber)
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 saltfpmask(images, outimages, outpref, axc,ayc, arad, maskmethod='c', maskvalue=0, \ radi=None,rado=None,clobber=False, logfile='saltfp.log', verbose=True): """Aperture masks Fabry-Perot images""" 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 the image hdu=saltio.openfits(img) #test that the data are in the first try: data=hdu[0].data except Exception, e: message='SALTFPMASK--ERROR: Could not access data in Primary exention of %s because %s' % (img, e) log.message(message) #determine the mask value if it is a region if maskmethod=='region': maskvalue=calc_maskvalue(data, axc, ayc, radi, rado) #mask the image message="SALTFPMASK--Masking image %s with a value of %s" % (img, maskvalue) log.message(message, with_header=False) hdu[0].data= maskimage(data, axc, ayc, arad, maskvalue) try: pass except Exception, e: message='SALTFPMASK--ERROR: Could not create mask for %s because %s' % (img, e) log.message(message) #write out the image saltio.writefits(hdu, oimg, clobber=clobber)
def saltfpzeropoint(images,outimages, outpref, calfile, fpa, fpb, fpc, fpd, fpe, fpf, clobber=False,logfile='salt.log',verbose=True): """Adds zeropoint information to each image""" with logging(logfile,debug) as log: # Check the input images infiles = saltio.argunpack ('Input',images) # create the 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') #calculate the zeropoint coefficients fpcoef=np.array([fpa,fpb,fpc,fpd,fpe,fpf]) zpcoef,tstart=calc_zpcoef(calfile, fpcoef) # open each image and detect the ring for img, oimg in zip(infiles, outfiles): hdu=saltio.openfits(img) #get the image time t=(get_datetime(hdu)-tstart).seconds #add the header values to the image saltkey.new('FPA',fpa+zpcoef[1]+zpcoef[0]*t,'FPA Coef',hdu[0]) saltkey.new('FPB',fpb,'FPB Coef',hdu[0]) saltkey.new('FPC',fpc,'FPC Coef',hdu[0]) saltkey.new('FPD',fpd,'FPD Coef',hdu[0]) saltkey.new('FPE', 0,'FPE Coef',hdu[0]) saltkey.new('FPF',fpf,'FPF Coef',hdu[0]) #write the file out saltio.writefits(hdu, oimg, clobber) #log the action msg='Updating the FP information in %s' % (img) log.message(msg, with_stdout=verbose, with_header=False)
def specprepare(images,outimages,outpref,badpixelimage='', \ 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 SALTSpecError(msg) # open each raw image file for img, oimg, in zip(infiles, outfiles): #open the fits file struct=saltio.openfits(img) # prepare file struct=prepare(struct,badpixelstruct) # write FITS file saltio.writefits(struct,oimg, clobber=clobber) saltio.closefits(struct) message = 'SPECPREPARE -- %s => %s' % (img, oimg) log.message(message)
def saltfpprep(images, outimages, outpref, clobber=True, logfile='saltfp.log', verbose=True): """Prepares data for Fabry-Perot reductions""" 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): message="SALTFPPREP--Preparing image %s" % (img) log.message(message, with_header=False) try: convertsalt(img, oimg, clobber=clobber) except SaltError, e: log.message('%s' %e)
def saltfpprep(images, outimages, outpref, clobber=True, logfile='saltfp.log', verbose=True): """Prepares data for Fabry-Perot reductions""" 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): message="SALTFPPREP--Preparing image %s" % (img) log.message(message, with_header=False) try: convertsalt(img, oimg, clobber=clobber) except SaltError as e: log.message('%s' %e)
def salt2iraf(images,outimages,outpref,ext=1, 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') for img, oimg in zip(infiles, outfiles): message="SALT2IRAF--Converting %s to %s" % (img, oimg) log.message(message, with_header=False) try: convertsalt(img, oimg, ext=ext, clobber=clobber) except SaltError, e: log.message('%s' % e)
def specprepare(images, outimages, outpref, badpixelimage='', 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 as e: msg = 'badpixel image must be specificied\n %s' % e raise SALTSpecError(msg) # open each raw image file for img, oimg, in zip(infiles, outfiles): # open the fits file struct = saltio.openfits(img) # prepare file struct = prepare(struct, badpixelstruct) # write FITS file saltio.writefits(struct, oimg, clobber=clobber) saltio.closefits(struct) message = 'SPECPREPARE -- %s => %s' % (img, oimg) log.message(message)
def saltembed(images,outimages,outpref, 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 each raw image file for img, oimg, in zip(infiles, outfiles): #open the fits file struct=saltio.openfits(img) #get the number of CCDs nccd=saltkey.get('NCCDS', struct[0]) #set the number of amps per CCD--*TODO* Read from header namps=2 #get the number of windows--try to read from header try: nwindows=saltkey.get('NWINDOWS', struct[0]) except: nwindows=len(struct)/(nccd*namps) outstruct=embedimage(struct, nccd, namps, nwindows) saltio.writefits(outstruct, oimg, clobber=clobber) message = 'SALTEMBED -- %s => %s' % (img, oimg) log.message(message, with_header=False)
def slotback(images, outfits, extension, imgtype='image', subbacktype='median', sigback=3, mbin=7, sorder=3, niter=5, ampperccd=2, ignorexp=6, clobber=False, logfile='salt.log', verbose=True): with logging(logfile, debug) as log: # set up the variables order = sorder plotfreq = 0.01 ftime = plotfreq # is the input file specified? infiles = saltio.argunpack('Input', images) # is the output file specified? saltio.filedefined('Output', outfits) #open the first file and check its charactistics struct = saltio.openfits(infiles[0]) # how many extensions? nextend = saltkey.get('NEXTEND', struct[0]) if nextend < extension: msg = 'Insufficient number of extensions in %s' % (infile) raise SaltIOError(msg) # how many amplifiers? amplifiers = saltkey.get('NCCDS', struct[0]) amplifiers = int(ampperccd * float(amplifiers)) if ampperccd > 0: nframes = nextend / amplifiers nstep = amplifiers else: nframes = nextend nstep = 1 ntotal = nframes * len(infiles) # image size naxis1 = saltkey.get('NAXIS1', struct[extension]) naxis2 = saltkey.get('NAXIS2', struct[extension]) # CCD binning ccdsum = saltkey.get('CCDSUM', struct[0]) binx = int(ccdsum.split(' ')[0]) biny = int(ccdsum.split(' ')[1]) # If a total file is to written out, create it and update it hdu = 1 # delete the file if clobber is on and the file exists if os.path.isfile(outfits): if clobber: saltio.delete(outfits) else: raise SaltIOError( 'Output fits file ' + writenewfits + 'already exists. Use Clobber=yes to overwrite file') # create the output file 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(outfits) except: raise SaltIOError('Could not create new fits file named ' + writenewfits) # read it back in for updating hduList = saltio.openfits(outfits, mode='update') # set up the completeness tracker if verbose: j = 0 x2 = float(j) / float(ntotal) ctext = 'Percentage Complete: %3.2f' % x2 sys.stdout.write(ctext) sys.stdout.flush() for infile in infiles: struct = saltio.openfits(infile) # Skip through the frames and process each frame individually for i in range(nframes): if not (infile == infiles[0] and i < ignorexp): hdu = extension + i * nstep try: header = struct[hdu].header array = struct[hdu].data array = array * 1.0 except Exception, e: msg = 'Unable to open extension %i in image %s because %s' % ( hdu, infile, e) raise SaltIOError(msg) # start the analysis of each frame # gain and readout noise try: gain = float(header['GAIN']) except: gain = 1 log.warning('Gain not specified in image header') try: rdnoise = float(header['RDNOISE']) except: rdnoise = 0 log.warning('RDNOISE not specified in image header') # background subtraction if not subbacktype == 'none': try: narray = subbackground(array, sigback, mbin, order, niter, subbacktype) except: log.warning('Image ' + infile + ' extention ' + str(i) + ' is blank, skipping') continue # create output array try: if imgtype == 'background': oarray = narray - array else: oarray = narray except: oarray = array # print progress if verbose: x2 = float(j) / float(ntotal) if x2 > ftime: ctext = '\b\b\b\b\b %3.2f' % x2 sys.stdout.write(ctext) sys.stdout.flush() ftime += plotfreq # update the header values with the image name and extension number try: hdue = pyfits.ImageHDU(oarray) hdue.header = header hdue.header.update('ONAME', infile, 'Original image name') hdue.header.update('OEXT', hdu, 'Original extension number') except Exception, e: msg='SALTPHOT--WARNING: Could not update image in newfits file for %s ext %i because %s' \ % (infile, hdu, e) raise SaltIOError(msg) hduList.append(hdue) j += 1 # close FITS file saltio.closefits(struct)
def saltclean(images, outpath, obslogfile=None, gaindb=None, xtalkfile=None, geomfile=None, subover=True, trim=True, masbias=None, subbias=False, median=False, function='polynomial', order=5, rej_lo=3, rej_hi=3, niter=5, interp='linear', clobber=False, logfile='salt.log', verbose=True): """SALTCLEAN will provide basic CCD reductions for a set of data. It will sort the data, and first process the biases, flats, and then the science frames. It will record basic quality control information about each of the steps. """ plotover = False #start logging with logging(logfile, debug) as log: # Check the input images infiles = saltio.argunpack('Input', images) # create list of output files outpath = saltio.abspath(outpath) #does the gain database file exist if gaindb: dblist = saltio.readgaindb(gaindb) else: dblist = [] # does crosstalk coefficient data exist if xtalkfile: xtalkfile = xtalkfile.strip() xdict = saltio.readxtalkcoeff(xtalkfile) else: xdict = None #does the mosaic file exist--raise error if no saltio.fileexists(geomfile) # Delete the obslog file if it already exists if os.path.isfile(obslogfile) and clobber: saltio.delete(obslogfile) #read in the obsveration log or create it if os.path.isfile(obslogfile): msg = 'The observing log already exists. Please either delete it or run saltclean with clobber=yes' raise SaltError(msg) else: headerDict = obslog(infiles, log) obsstruct = createobslogfits(headerDict) saltio.writefits(obsstruct, obslogfile) #create the list of bias frames and process them filename = obsstruct.data.field('FILENAME') detmode = obsstruct.data.field('DETMODE') ccdtype = obsstruct.data.field('CCDTYPE') #set the bias list of objects biaslist = filename[ccdtype == 'ZERO'] masterbias_dict = {} for img in infiles: if os.path.basename(img) in biaslist: #open the image struct = fits.open(img) bimg = outpath + 'bxgp' + os.path.basename(img) #print the message if log: message = 'Processing Zero frame %s' % img log.message(message, with_stdout=verbose) #process the image struct = clean(struct, createvar=False, badpixelstruct=None, mult=True, dblist=dblist, xdict=xdict, subover=subover, trim=trim, subbias=False, bstruct=None, 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], 'SPREPARE', 'Images have been prepared', hist) saltkey.new('SGAIN', time.asctime(time.localtime()), 'Images have been gain corrected', struct[0]) saltkey.new('SXTALK', time.asctime(time.localtime()), 'Images have been xtalk corrected', struct[0]) saltkey.new('SBIAS', time.asctime(time.localtime()), 'Images have been de-biased', struct[0]) # write FITS file saltio.writefits(struct, bimg, clobber=clobber) saltio.closefits(struct) #add files to the master bias list masterbias_dict = compareimages(struct, bimg, masterbias_dict, keylist=biasheader_list) #create the master bias frame for i in masterbias_dict.keys(): bkeys = masterbias_dict[i][0] blist = masterbias_dict[i][1:] mbiasname = outpath + createmasterbiasname(blist, bkeys) bfiles = ','.join(blist) saltcombine(bfiles, mbiasname, method='median', reject='sigclip', mask=False, weight=False, blank=0, scale=None, statsec=None, lthresh=3, \ hthresh=3, clobber=False, logfile=logfile,verbose=verbose) #create the list of flatfields and process them flatlist = filename[ccdtype == 'FLAT'] masterflat_dict = {} for img in infiles: if os.path.basename(img) in flatlist: #open the image struct = fits.open(img) fimg = outpath + 'bxgp' + os.path.basename(img) #print the message if log: message = 'Processing Flat frame %s' % img log.message(message, with_stdout=verbose) #process the image struct = clean(struct, createvar=False, badpixelstruct=None, mult=True, dblist=dblist, xdict=xdict, subover=subover, trim=trim, subbias=False, bstruct=None, 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], 'SPREPARE', 'Images have been prepared', hist) saltkey.new('SGAIN', time.asctime(time.localtime()), 'Images have been gain corrected', struct[0]) saltkey.new('SXTALK', time.asctime(time.localtime()), 'Images have been xtalk corrected', struct[0]) saltkey.new('SBIAS', time.asctime(time.localtime()), 'Images have been de-biased', struct[0]) # write FITS file saltio.writefits(struct, fimg, clobber=clobber) saltio.closefits(struct) #add files to the master bias list masterflat_dict = compareimages(struct, fimg, masterflat_dict, keylist=flatheader_list) #create the master flat frame for i in masterflat_dict.keys(): fkeys = masterflat_dict[i][0] flist = masterflat_dict[i][1:] mflatname = outpath + createmasterflatname(flist, fkeys) ffiles = ','.join(flist) saltcombine(ffiles, mflatname, method='median', reject='sigclip', mask=False, weight=False, blank=0, scale=None, statsec=None, lthresh=3, \ hthresh=3, clobber=False, logfile=logfile,verbose=verbose) #process the science data for img in infiles: nimg = os.path.basename(img) #print nimg, nimg in flatlist, nimg in biaslist if not (nimg in biaslist): #open the image struct = fits.open(img) simg = outpath + 'bxgp' + os.path.basename(img) #print the message if log: message = 'Processing science frame %s' % img log.message(message, with_stdout=verbose) #process the image struct = clean(struct, createvar=False, badpixelstruct=None, mult=True, dblist=dblist, xdict=xdict, subover=subover, trim=trim, subbias=False, bstruct=None, 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], 'SPREPARE', 'Images have been prepared', hist) saltkey.new('SGAIN', time.asctime(time.localtime()), 'Images have been gain corrected', struct[0]) saltkey.new('SXTALK', time.asctime(time.localtime()), 'Images have been xtalk corrected', struct[0]) saltkey.new('SBIAS', time.asctime(time.localtime()), 'Images have been de-biased', struct[0]) # write FITS file saltio.writefits(struct, simg, clobber=clobber) saltio.closefits(struct) #mosaic the files--currently not in the proper format--will update when it is if not saltkey.fastmode(saltkey.get('DETMODE', struct[0])): mimg = outpath + 'mbxgp' + os.path.basename(img) saltmosaic(images=simg, outimages=mimg, outpref='', geomfile=geomfile, interp=interp, cleanup=True, clobber=clobber, logfile=logfile, verbose=verbose) #remove the intermediate steps saltio.delete(simg)
def specarcstraighten(images, outfile, function='poly', order=3, rstep=1, rstart='middlerow', nrows=1, y1=None, y2=None, sigma=5, sections=3, niter=5, startext=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.argunpack('Output', outfile) # Identify the lines in each file for img, ofile in zip(infiles, outfiles): # open the image hdu = saltio.openfits(img) # get the basic information about the spectrograph dateobs = saltkey.get('DATE-OBS', hdu[0]) try: utctime = saltkey.get('UTC-OBS', hdu[0]) except SaltError: utctime = saltkey.get('TIME-OBS', hdu[0]) instrume = saltkey.get('INSTRUME', hdu[0]).strip() grating = saltkey.get('GRATING', hdu[0]).strip() grang = saltkey.get('GR-ANGLE', hdu[0]) grasteps = saltkey.get('GRTILT', hdu[0]) arang = saltkey.get('AR-ANGLE', hdu[0]) arsteps = saltkey.get('CAMANG', hdu[0]) rssfilter = saltkey.get('FILTER', hdu[0]) specmode = saltkey.get('OBSMODE', hdu[0]) masktype = saltkey.get('MASKTYP', hdu[0]).strip().upper() slitname = saltkey.get('MASKID', hdu[0]) xbin, ybin = saltkey.ccdbin(hdu[0], img) for i in range(startext, len(hdu)): if hdu[i].name == 'SCI': log.message('Proccessing extension %i in %s' % (i, img)) # things that will change for each slit if masktype == 'LONGSLIT': slit = st.getslitsize(slitname) objid = None #elif masktype == 'MOS': #slit = 1.5 # slit=saltkey.get('SLIT', hdu[i]) # set up the x and y positions #miny = hdu[i].header['MINY'] #maxy = hdu[i].header['MAXY'] #ras = hdu[i].header['SLIT_RA'] #des = hdu[i].header['SLIT_DEC'] #objid = hdu[i].header['SLITNAME'] # Check the perfomance of masks at different PA #rac = hdu[0].header['MASK_RA'] #dec = hdu[0].header['MASK_DEC'] #pac = hdu[0].header['PA'] else: msg = '%s is not a currently supported masktype' % masktype raise SALTSpecError(msg) if instrume not in ['PFIS', 'RSS']: msg = '%s is not a currently supported instrument' % instrume raise SALTSpecError(msg) # set up the data for the source try: data = hdu[i].data except Exception as e: message = 'Unable to read in data array in %s because %s' % ( img, e) raise SALTSpecError(message) # set up the center row if rstart == 'middlerow': ystart = int(0.5 * len(data)) else: ystart = rstart # set up the xarr array based on the image xarr = np.arange(len(data[ystart]), dtype='int64') # calculate the transformation ImageSolution = arcstraight(data, xarr, ystart, function=function, order=order, rstep=rstep, y1=y1, y2=y2, sigma=sigma, sections=sections, niter=niter, log=log, verbose=verbose) if outfile and len(ImageSolution): writeIS(ImageSolution, outfile, dateobs=dateobs, utctime=utctime, instrume=instrume, grating=grating, grang=grang, grasteps=grasteps, arsteps=arsteps, arang=arang, rfilter=rssfilter, slit=slit, xbin=xbin, ybin=ybin, objid=objid, filename=img, log=log, verbose=verbose)
def specslitnormalize(images, outimages, outpref, response=None, response_output=None, order=2, conv=1e-2, niter=20, startext=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, '') # read in the response function response = saltio.checkfornone(response) if response: log.message('Loading response from %s' % response) response = readresponse(response) # Identify the lines in each file for img, ofile in zip(infiles, outfiles): # open the image hdu = saltio.openfits(img) for i in range(startext, len(hdu)): if hdu[i].name == 'SCI': log.message('Normalizing extension %i in %s' % (i, img)) # things that will change for each slit # set up the data for the source try: data = hdu[i].data except Exception as e: message = \ 'Unable to read in data array in %s because %s' % \ (img, e) raise SALTSpecError(message) if response is None: response = create_response(data, spatial_axis=1, order=order, conv=conv, niter=niter) if response_output: write_response(response, clobber=clobber) else: # add a check that the response is the same shape as # the data if len(response) != data.shape[0]: raise SALTSpecError( 'Length of response function does not equal size of image array' ) # correct the data data = data / response # correct the variance frame if saltkey.found('VAREXT', hdu[i]): vhdu = saltkey.get('VAREXT', hdu[i]) hdu[vhdu].data = hdu[vhdu].data / response saltio.writefits(hdu, ofile, clobber=clobber)
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 specslit(image, outimage, outpref, exttype='auto', slitfile='', outputslitfile='', regprefix='', sections=3, width=25, sigma=2.2, thres=6, order=3, padding=5, yoffset=0, inter=False, clobber=True, logfile='salt.log', verbose=True): with logging(logfile, debug) as log: # check all the input and make sure that all the input needed is provided # by the user # read the image or image list and check if each in the list exist infiles = saltio.argunpack('Input', image) # unpack the outfiles outfiles = saltio.listparse('Outimages', outimage, outpref, infiles, '') # from the extraction type, check whether the input file is specified. # if the slitfile parameter is specified then use the slit files for # the extraction. if the extraction type is auto then use image for the # detection and the slit extraction if exttype == 'rsmt' or exttype == 'fits' or exttype == 'ascii' or exttype == 'ds9': slitfiles = saltio.argunpack('Slitfile', slitfile) if len(slitfiles) == 1: slitfiles = slitfiles * len(infiles) saltio.comparelists(infiles, slitfiles, 'image', 'slitfile') elif exttype == 'auto': slitfiles = infiles log.message( 'Extraction type is AUTO. Slit detection will be done from image' ) # read in if an optional ascii file is requested if len(outputslitfile) > 0: outslitfiles = saltio.argunpack('Outslitfiles', outputslitfile) saltio.comparelists(infiles, outslitfiles, 'image', 'outputslitfile') else: outslitfiles = [''] * len(infiles) # check if the width and sigma parameters were specified. # default is 25 and 2.2 if width < 10.: msg = 'The width parameter needs be a value larger than 10' raise SALTSpecError(msg) if sigma < 0.0: msg = 'Sigma must be greater than zero' raise SaltSpecError(msg) # check the treshold parameter. this needs to be specified by the user if thres <= 0.0: msg = 'Threshold must be greater than zero' raise SaltSpecError(msg) # check to make sure that the sections are greater than the order if sections <= order: msg = 'Number of sections must be greater than the order for the spline fit' raise SaltSpecError(msg) # run through each of the images and extract the slits for img, oimg, sfile, oslit in zip(infiles, outfiles, slitfiles, outslitfiles): log.message('Proccessing image %s' % img) # open the image struct = saltio.openfits(img) ylen, xlen = struct[1].data.shape xbin, ybin = saltkey.ccdbin(struct[0], img) # setup the VARIANCE and BPM frames if saltkey.found('VAREXT', struct[1]): varext = saltkey.get('VAREXT', struct[1]) varlist = [] else: varext = None # setup the BPM frames if saltkey.found('BPMEXT', struct[1]): bpmext = saltkey.get('BPMEXT', struct[1]) bpmlist = [] else: bpmext = None # open the slit definition file or identify the slits in the image slitmask = None ycheck = False if exttype == 'rsmt': log.message('Using slits from %s' % sfile) if yoffset is None: yoffset = 0 ycheck = True slitmask = mt.read_slitmask_from_xml(sfile) xpos = -0.3066 ypos = 0.0117 cx = int(xlen / 2.0) cy = int(ylen / 2.0) + ypos / 0.015 / ybin + yoffset order, slit_positions = mt.convert_slits_from_mask( slitmask, order=1, xbin=xbin, ybin=ybin, pix_scale=0.1267, cx=cx, cy=cy) sections = 1 elif exttype == 'fits': log.message('Using slits from %s' % sfile) order, slit_positions = read_slits_from_fits(sfile) elif exttype == 'ascii': log.message('Using slits from %s' % sfile) order, slit_positions = mt.read_slits_from_ascii(sfile) elif exttype == 'ds9': log.message('Using slits from %s' % sfile) order, slit_positions, slitmask = mt.read_slits_from_ds9( sfile, order=order) slitmask = None sections = 1 elif exttype == 'auto': log.message('Identifying slits in %s' % img) # identify the slits in the image order, slit_positions = identify_slits(struct[1].data, order, sections, width, sigma, thres) # write out the slit identifications if ofile has been supplied if oslit: log.message('Writing slit positions to %s' % oslit) mt.write_outputslitfile(slit_positions, oslit, order) if ycheck: slit_positions, dy = check_ypos(slit_positions, struct[1].data) log.message('Using an offset of {}'.format(dy)) # extract the slits spline_x = mt.divide_image(struct[1].data, sections) spline_x = 0.5 * (np.array(spline_x[:-1]) + np.array(spline_x[1:])) extracted_spectra, spline_positions = mt.extract_slits( slit_positions, spline_x, struct[1].data, order=order, padding=padding) if varext: extracted_var, var_positions = mt.extract_slits( slit_positions, spline_x, struct[varext].data, order=order, padding=padding) if bpmext: extracted_bpm, bpm_positions = mt.extract_slits( slit_positions, spline_x, struct[bpmext].data, order=order, padding=padding) # write out the data to the new array # create the new file hdulist = fits.HDUList([struct[0]]) # log the extracted spectra if needed log.message('', with_stdout=verbose) # setup output ds9 file if regprefix: regout = open( regprefix + os.path.basename(img).strip('.fits') + '.reg', 'w') regout.write('# Region file format: DS9 version 4.1\n') regout.write('# Filename: %s\n' % img) regout.write( 'global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1\nphysical\n' ) # add each imglist = [] nslits = len(spline_positions) for i in range(nslits): y1 = spline_positions[i][0].min() y2 = spline_positions[i][1].max() msg = 'Extracted Spectra %i between %i to %i' % (i + 1, y1, y2) # log.message(msg, with_header=False, with_stdout=verbose) sdu = fits.ImageHDU(extracted_spectra[i], header=struct[1].header) if varext: vdu = fits.ImageHDU(extracted_var[i], header=struct[varext].header) sdu.header['VAREXT'] = i + nslits + 1 varlist.append(vdu) if bpmext: bdu = fits.ImageHDU(extracted_bpm[i], header=struct[bpmext].header) sdu.header['BPMEXT'] = i + 2 * nslits + 1 bpmlist.append(bdu) imglist.append(sdu) # add in some additional keywords imglist[i].header['MINY'] = (y1, 'Lower Y value in original image') imglist[i].header['MAXY'] = (y2, 'Upper Y value in original image') if regprefix: xsize = struct[1].data.shape[1] xsize = int(0.5 * xsize) rtext = '' if slitmask: # rtext='%s, %8.7f, %8.7f, %3.2f' % (slitmask.slitlets.data[i]['name'], slitmask.slitlets.data[i]['targ_ra'], slitmask.slitlets.data[i]['targ_dec'], slitmask.slitlets.data[i]['slit_width']) pass regout.write('box(%i,%i, %i, %i) #text={%s}\n' % (xsize, 0.5 * (y1 + y2), 2 * xsize, y2 - y1, rtext)) # add slit information if slitmask: imglist[i].header['SLITNAME'] = ( slitmask.slitlets.data[i]['name'], 'Slit Name') imglist[i].header['SLIT_RA'] = ( slitmask.slitlets.data[i]['targ_ra'], 'Slit RA') imglist[i].header['SLIT_DEC'] = ( slitmask.slitlets.data[i]['targ_dec'], 'Slit DEC') imglist[i].header['SLIT'] = ( slitmask.slitlets.data[i]['slit_width'], 'Slit Width') # add to the hdulist hdulist += imglist if varext: hdulist += varlist if bpmext: hdulist += bpmlist # write the slit positions to the header # create the binary table HDU that contains the split positions tbhdu = mt.slits_HDUtable(slit_positions, order) bintable_hdr = tbhdu.header # add the extname parameter to the extension tbhdu.header['EXTNAME'] = 'BINTABLE' # add the extname parameter to the extension hdulist[0].header['SLITEXT'] = len(hdulist) hdulist.append(tbhdu) # add addition header information about the mask if slitmask: hdulist[0].header['MASKNAME'] = (slitmask.mask_name, 'SlitMask Name') hdulist[0].header['MASK_RA'] = (slitmask.center_ra, 'SlitMask RA') hdulist[0].header['MASK_DEC'] = (slitmask.center_dec, 'SlitMask DEC') hdulist[0].header['MASK_PA'] = (slitmask.position_angle, 'SlitMask Position Angle') # write out the image saltio.writefits(hdulist, oimg, clobber)
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 saltmosaic(images, outimages, outpref, geomfile, interp='linear', geotran=True, fill=False, 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, fill=fill, 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 ostruct.writeto(oimg, clobber=clobber, output_verify='ignore') # close the files struct.close() ostruct.close()