Ejemplo n.º 1
0
def combine_flat(flatlist,outfilepath="flat.fits"):
    """Combines a series of flatfield exposures to create a single flatfield
    image. Uses only the information contained inside the RSS aperture, which
    is the only significant difference between this routine and the familiar
    flat combination routines common to CCD astronomy.
    
    Inputs:
    flatlist -> A list of strings, each the path to a flatfield exposure
    outfilepath -> A string, the path of the output file (default 'flat.fits')
    
    """
    
    imagelist = []
    for i in range(len(flatlist)):
        imagelist.append(openfits(flatlist[i]))
        xgrid, ygrid = np.meshgrid(np.arange(imagelist[i][0].data.shape[1]),np.arange(imagelist[i][0].data.shape[0]))
        imagelist[i][0].data=imagelist[i][0].data/np.median(imagelist[i][0].data[np.power((xgrid-imagelist[i][0].header["fpaxcen"]),2)+np.power((ygrid-imagelist[i][0].header["fpaycen"]),2)<np.power(imagelist[i][0].header["fparad"],2)])
    imagestack = np.empty((len(flatlist),imagelist[0][0].data.shape[0],imagelist[0][0].data.shape[1]))
    for i in range(len(flatlist)):
        imagestack[i,:,:] = imagelist[i][0].data
    flatarray = np.median(imagestack,axis=0)
    flatarray[flatarray<0.000001]=0
    writefits(outfilepath,flatarray,clobber=True)
    
    #Close images
    for i in range(len(flatlist)): imagelist[i].close()
    
    return
Ejemplo n.º 2
0
def fit_velmap_ha_n2_mode(wavelist, intylist, outdir, uncertlist=None, clobber=False):
    """
    """
    #Create blank lists for filling with images
    wavefilelist = []
    intyfilelist = []
    if not (uncertlist is None):
        uncertfilelist = []
    #Open images and populate the lists
    for i in range(len(wavelist)):
        wavefilelist.append(openfits(wavelist[i]))
        intyfilelist.append(openfits(intylist[i]))
        if not (uncertlist is None):
            uncertfilelist.append(openfits(uncertlist[i]))
    #Create blank arrays for filling with data
    wavecube = np.zeros((intyfilelist[0][0].data.shape[0],intyfilelist[0][0].data.shape[1],len(wavelist)))
    intycube = np.zeros((intyfilelist[0][0].data.shape[0],intyfilelist[0][0].data.shape[1],len(wavelist)))
    if not (uncertlist is None):
        uncertcube = np.zeros((intyfilelist[0][0].data.shape[0],intyfilelist[0][0].data.shape[1],len(wavelist)))
    #Fill the cube arrays with data
    for i in range(len(wavelist)):
        wavecube[:,:,i] = wavefilelist[i][0].data
        intycube[:,:,i] = intyfilelist[i][0].data
        if not (uncertlist is None):
            uncertcube[:,:,i] = uncertfilelist[i][0].data
    #Create blank arrays for the velocity+etc fits
    contarray = np.zeros_like(wavefilelist[0][0].data)
    intyarray = np.zeros_like(wavefilelist[0][0].data)
    intyratioarray = np.zeros_like(wavefilelist[0][0].data)
    wavearray = np.zeros_like(wavefilelist[0][0].data)
    two_line_success_array = np.zeros_like(wavefilelist[0][0].data,dtype="bool")
    one_line_success_array = np.zeros_like(wavefilelist[0][0].data,dtype="bool")
    #Create x and y arrays for the "progress bar"
    numb_updates=20 #Number of progress updates
    xgrid, ygrid = np.meshgrid(np.arange(contarray.shape[1]),np.arange(contarray.shape[0]))
    xgrid = xgrid.flatten()
    ygrid = ygrid.flatten()
    progX = []
    progY = []
    progPerc = []
    for i in range(1,numb_updates+1):
        progX.append(xgrid[np.int(len(xgrid)*i/numb_updates)-1])
        progY.append(ygrid[np.int(len(xgrid)*i/numb_updates)-1])
        progPerc.append(i*100/numb_updates)
    progX = np.array(progX)
    progY = np.array(progY)
    progPerc = np.array(progPerc)
    #Loop over pixels
    for y in range(wavearray.shape[0]):
        for x in range(wavearray.shape[1]):
            #Display the "progress bar" if appropriate
            if np.any(np.logical_and(x==progX,y==progY)): print "Velocity map approximately "+repr(progPerc[np.logical_and(progX==x,progY==y)][0])+"% complete..."
            #Get the spectrum to fit
            waves = wavecube[y,x,:]
            intys = intycube[y,x,:]
            if not (uncertlist is None): uncerts = uncertcube[y,x,:]
            else: uncerts = None
            
#             #Attempt the two-lined fit (halpha and NII)
#             if np.sum(waves!=0)>0.5*len(waves): fit, success = fit_ha_and_n2(waves[waves!=0], intys[intys!=0], uncerts[uncerts!=0])
#             else: fit, success = np.zeros(8), False
#             #Was the fit successful
#             if success:
#                 contarray[y,x] = fit[0]
#                 intyarray[y,x] = fit[1]
#                 intyratioarray[y,x] = fit[2]/fit[1]
#                 wavearray[y,x] = fit[3]
#                 two_line_success_array[y,x] = True
#             #If not, let's try only fitting the halpha line
#             else:
#                 if np.sum(waves!=0)>0.5*len(waves): fit, success = fit_only_ha(waves[waves!=0], intys[intys!=0], uncerts[uncerts!=0])
#                 else: fit, success = np.zeros(5), False
#                 if success:
#                     contarray[y,x] = fit[0]
#                     intyarray[y,x] = fit[1]
#                     wavearray[y,x] = fit[2]
#                     one_line_success_array[y,x] = True
            #Fit with voigtfit
            
            if np.sum(waves!=0)>0.5*len(waves):
                fit,_err,_chi2 = voigtfit.voigtfit(waves[waves!=0],intys[intys!=0],uncerts[uncerts!=0],voigtfit.voigtguess(waves[waves!=0],intys[intys!=0]),[True,True,True,True,True])
                contarray[y,x] = fit[0]
                intyarray[y,x] = fit[1]
                wavearray[y,x] = fit[2]
    #Convert wavelengths to velocities
    velarray = np.zeros_like(wavearray)
    velarray[wavearray!=0] = 299792.458*((wavearray[wavearray!=0]/6562.81)**2-1)/((wavearray[wavearray!=0]/6562.81)**2+1)
    #Save the output images
    writefits(join(outdir,"velocity.fits"), velarray, clobber=clobber)
    writefits(join(outdir,"intensity.fits"), intyarray, clobber=clobber)
    writefits(join(outdir,"intyratio.fits"), intyratioarray, clobber=clobber)
    writefits(join(outdir,"continuum.fits"), contarray, clobber=clobber)
    #writefits(join(outdir,"2linesuccess.fits"), two_line_success_array, clobber=clobber)
    #writefits(join(outdir,"1linesuccess.fits"), one_line_success_array, clobber=clobber)
    #Close input images
    for i in range(len(wavelist)):
        wavefilelist[i].close()
        intyfilelist[i].close()
        if not (uncertlist is None):
            uncertfilelist[i].close()
    
    return
Ejemplo n.º 3
0
def make_final_image(input_image, output_image, output_wave_image,
                     desired_fwhm,
                     input_uncert_image=None, output_uncert_image=None,
                     clobber=False):
    """This routine makes the 'final' images for a data cube. At least the paths
    to the input image, output image, and output wavelength image are necessary
    for this. Beyond that, the user may also have the routine create uncertainty
    images as well.
    
    Images are convolved to the resolution 'desired_fwhm'. If the current fwhm
    is already higher than that, the routine will throw an error.
    
    A number of fits header keywords are necessary for this program to function
    properly. Any of these missing will throw an error.
    
    The output images are intensity-weighted, i.e. the wavelength image will be
    created such that the wavelengths at each pixel are the 'most likely'
    wavelength for the intensity at that pixel, etc.
    
    Inputs:
    input_image -> Path to the input image.
    output_image -> Path to the output image.
    output_wave_image -> Path to the output wavelength image.
    desired_fwhm -> Desired FWHM for the resultant image to have.
    
    Optional Inputs:
    input_uncert_image -> Path to the input uncertainty image, if it exists.
    output_uncert_image -> Path to the output uncertainty image, if it exists.
    clobber -> Overwrite output images if they already exist. Default is False.
    
    """
    
    print "Making final data cube images for image "+input_image
    
    #Measure the sky background level in the input image
    skyavg, skysig = fit_sky_level([input_image])
    
    #Open the input image and get various header keywords, crash if necessary
    intyimage = openfits(input_image)
    intygrid = intyimage[0].data
    fwhm = intyimage[0].header.get("fpfwhm")
    wave0 = intyimage[0].header.get("fpwave0")
    calf = intyimage[0].header.get("fpcalf")
    xcen = intyimage[0].header.get("fpxcen")
    ycen = intyimage[0].header.get("fpycen")
    if fwhm == None: crash("Error! FWHM not measured for image "+input_image+".")
    if wave0 == None or calf == None: crash("Error! Wavelength solution does "+
                                            "not exist for image "+input_image+".")
    if xcen == None or ycen == None: crash("Error! Center values not measured "+
                                           "image "+input_image+".")
    if fwhm>desired_fwhm: crash("Error! Desired FWHM too low for image "+
                                input_image+".")
    
    #Subtract the sky background from the image
    intygrid[intygrid!=0] -= skyavg[0]
    
    #Calculate the necessary FWHM for convolution and make the gaussian kernel
    fwhm_conv = np.sqrt(desired_fwhm**2-fwhm**2)
    sig = fwhm_conv/2.3548+0.0001
    ksize = np.ceil(4*sig) #Generate the kernel to 4-sigma
    kxgrid, kygrid = np.meshgrid(np.linspace(-ksize,ksize,2*ksize+1),np.linspace(-ksize,ksize,2*ksize+1))
    kern = np.exp(-(kxgrid**2+kygrid**2)/(2*sig**2)) #Gaussian (unnormalized because sig can be 0)
    kern = kern/np.sum(kern) #Normalize the kernel
    
    #Open and convolve the uncertainty image if one exists. Save the output.
    if input_uncert_image != None:
        uncertimage = openfits(input_uncert_image)
        uncertgrid = uncertimage[0].data
        #Add the sky background uncertainty to the uncertainty grid
        uncertgrid[intygrid!=0] = np.sqrt(uncertgrid[intygrid!=0]**2+skysig[0]**2)
        #Convolve the uncertainties appropriately
        new_uncert_grid = convolve_uncert(uncertgrid, intygrid, kern)
        #Write to output file
        writefits(output_uncert_image,new_uncert_grid,header=uncertimage[0].header,clobber=clobber)
        uncertimage.close()
        
    #Create and convolve the wavelength image. Save the output.
    xgrid, ygrid = np.meshgrid(np.arange(intyimage[0].data.shape[1]),
                               np.arange(intyimage[0].data.shape[0]))
    r2grid = (xgrid-xcen)**2 + (ygrid-ycen)**2
    wavegrid = wave0 / np.sqrt(1+r2grid/calf**2)
    newwavegrid = convolve_wave(wavegrid, intygrid, kern)
    writefits(output_wave_image,newwavegrid,header=intyimage[0].header,clobber=clobber)
    
    #Convolve the intensity image. Save the output
    newintygrid = convolve_inty(intygrid, kern)
    intyimage[0].header["fpfwhm"] = desired_fwhm #Update header FWHM keyword
    writefits(output_image,newintygrid,header=intyimage[0].header,clobber=clobber)
    
    #Close images
    intyimage.close()
    
    return