Пример #1
0
    def __init__(self, filename):
        """
        Load PSF parameters from a file

        Loads x, y, wavelength information for spectral traces and fills:
            self.npix_x   #- number of columns in the target image
            self.npix_y   #- number of rows in the target image
            self.nspec    #- number of spectra (fibers)
            self.nwave    #- number of wavelength samples per spectrum

        Subclasses of this class define the xypix(ispec, wavelength) method
        to access the projection of this PSF into pixels.
        """

        #- Load basic dimensions
        hdr = fits.getheader(filename)
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']
        self.nspec = hdr['NSPEC']

        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load x, y legendre coefficient tracesets
        with fits.open(filename) as fx:
            xc = fx['XCOEFF'].data
            hdr = fx['XCOEFF'].header
            self._x = TraceSet(xc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))
            yc = fx['YCOEFF'].data
            hdr = fx['YCOEFF'].header
            self._y = TraceSet(yc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))

        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()

        #- Cache min/max wavelength per fiber at pixel edges
        self._wmin_spec = self.wavelength(None, -0.5)
        self._wmax_spec = self.wavelength(None, self.npix_y - 0.5)
        self._wmin = np.min(self._wmin_spec)
        self._wmin_all = np.max(self._wmin_spec)
        self._wmax = np.max(self._wmax_spec)
        self._wmax_all = np.min(self._wmax_spec)

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None
Пример #2
0
    def __init__(self, filename):
        """
        Load PSF parameters from a file
        
        Loads x, y, wavelength information for spectral traces and fills:
            self.npix_x   #- number of columns in the target image
            self.npix_y   #- number of rows in the target image
            self.nspec    #- number of spectra (fibers)
            self.nwave    #- number of wavelength samples per spectrum

        Subclasses of this class define the xypix(ispec, wavelength) method
        to access the projection of this PSF into pixels.
        """
        
        #- Load basic dimensions
        hdr = fits.getheader(filename)
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']
        self.nspec  = hdr['NSPEC']
        
        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load x, y legendre coefficient tracesets
        with fits.open(filename) as fx:
            xc = fx['XCOEFF'].data
            hdr = fx['XCOEFF'].header
            self._x = TraceSet(xc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))
            yc = fx['YCOEFF'].data
            hdr = fx['YCOEFF'].header
            self._y = TraceSet(yc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))

        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()

        #- Cache min/max wavelength per fiber at pixel edges
        self._wmin_spec = self.wavelength(None, -0.5)
        self._wmax_spec = self.wavelength(None, self.npix_y-0.5)
        self._wmin = np.min(self._wmin_spec)
        self._wmin_all = np.max(self._wmin_spec)
        self._wmax = np.max(self._wmax_spec)
        self._wmax_all = np.min(self._wmax_spec)

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None
Пример #3
0
    def __init__(self, filename):
        """
        Load PSF parameters from a file
        
        Loads x, y, wavelength information for spectral traces and fills:
            self.npix_x   #- number of columns in the target image
            self.npix_y   #- number of rows in the target image
            self.nspec    #- number of spectra (fibers)
            self.nwave    #- number of wavelength samples per spectrum

        Subclasses of this class define the xypix(ispec, wavelength) method
        to access the projection of this PSF into pixels.
        """
        
        #- Load basic dimensions
        hdr = fits.getheader(filename)
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']
        self.nspec  = hdr['NSPEC']
        
        #- Load x, y legendre coefficient tracesets
        xc, hdr = fits.getdata(filename, 'XCOEFF', header=True)
        self._x = TraceSet(xc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))
        yc, hdr = fits.getdata(filename, 'YCOEFF', header=True)
        self._y = TraceSet(yc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))
        
        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()
        self._wmin = np.min(self.wavelength(None, 0))
        self._wmin_all = np.max(self.wavelength(None, 0))
        self._wmax = np.max(self.wavelength(None, self.npix_y-1))
        self._wmax_all = np.min(self.wavelength(None, self.npix_y-1))
                
        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None
Пример #4
0
class PSF(object):
    """
    Base class for 2D PSFs
    
    Subclasses need to extend __init__ to load format-specific items
    from the input fits file and implement _xypix(ispec, wavelength)
    to return xslice, yslice, pixels[y,x] for the PSF evaluated at
    spectrum ispec at the given wavelength.  All interactions with PSF
    classes should be via the methods defined here, allowing
    interchangeable use of different PSF models.
    """
    def __init__(self, filename):
        """
        Load PSF parameters from a file
        
        Loads x, y, wavelength information for spectral traces and fills:
            self.npix_x   #- number of columns in the target image
            self.npix_y   #- number of rows in the target image
            self.nspec    #- number of spectra (fibers)
            self.nwave    #- number of wavelength samples per spectrum

        Subclasses of this class define the xypix(ispec, wavelength) method
        to access the projection of this PSF into pixels.
        """
        
        #- Load basic dimensions
        hdr = fits.getheader(filename)
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']
        self.nspec  = hdr['NSPEC']
        
        #- Load x, y legendre coefficient tracesets
        xc, hdr = fits.getdata(filename, 'XCOEFF', header=True)
        self._x = TraceSet(xc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))
        yc, hdr = fits.getdata(filename, 'YCOEFF', header=True)
        self._y = TraceSet(yc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))
        
        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()
        self._wmin = np.min(self.wavelength(None, 0))
        self._wmin_all = np.max(self.wavelength(None, 0))
        self._wmax = np.max(self.wavelength(None, self.npix_y-1))
        self._wmax_all = np.min(self.wavelength(None, self.npix_y-1))
                
        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None
        
    #- Utility function to fit spot sigma vs. wavelength
    def _fit_spot_sigma(self, ispec, axis=0, npoly=5):
        """
        Fit the cross-sectional Gaussian sigma of PSF spots vs. wavelength.
        Return callable Legendre object.
        
        Inputs:
            ispec : spectrum number
            axis  : 0 or 'x' for cross dispersion sigma;
                    1 or 'y' or 'w' for wavelength dispersion
            npoly : order of Legendre poly to fit to sigma vs. wavelength
            
        Returns:
            legfit such that legfit(w) returns fit at wavelengths w
        """
        
        if type(axis) is not int:
            if axis in ('x', 'X'):
                axis = 0
            elif axis in ('y', 'Y', 'w', 'W'):
                axis = 1
            else:
                raise ValueError("Unknown axis type "+str(axis))
                
        if axis not in (0,1):
            raise ValueError("axis must be 0, 'x', 1, 'y', or 'w'")
            
        yy = np.linspace(10, self.npix_y-10, 20)
        ww = self.wavelength(ispec, y=yy)
        xsig = list()  #- sigma vs. wavelength array to fill
        for w in ww:
            xspot = self.pix(ispec, w).sum(axis=axis)
            xspot /= np.sum(xspot)       #- normalize for edge cases
            xx = np.arange(len(xspot))
            mean, sigma = scipy.optimize.curve_fit(gausspix, xx, xspot)[0]
            xsig.append(sigma)
        
        #- Fit Legendre polynomial and return coefficients
        legfit = Legendre.fit(ww, xsig, npoly, domain=(self._wmin, self._wmax))
                
        return legfit

    #-------------------------------------------------------------------------
    #- Cross dispersion width for row-by-row extractions
    def xsigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in cross-dispersion direction
        in CCD pixel units.
        
        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas
        
        The first time this is called for a spectrum, the PSF is sampled
        at 20 wavelengths and the variation is fit with a 5th order
        Legendre polynomial and the coefficients are cached.
        The actual value (and subsequent calls) use these cached
        Legendre fits to interpolate the sigma value.  If this is not
        fast enough and/or accurate enough, PSF subtypes may override
        this function to provide a more accurate xsigma measurement.
        """

        #- First call for any spectrum: setup array to cache coefficients
        if self._xsigma is None:
            self._xsigma = [None,] * self.nspec
            
        #- First call for this spectrum: calculate coefficients & cache
        if self._xsigma[ispec] is None:
            self._xsigma[ispec] = self._fit_spot_sigma(ispec, axis=0, npoly=5)

        #- Use cached Legendre fit to interpolate xsigma at wavelength(s)
        return self._xsigma[ispec](wavelength)

    #-------------------------------------------------------------------------
    #- Cross dispersion width for row-by-row extractions
    def ysigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in wavelength-dispersion direction
        in units of pixels.
        
        Also see wdisp(...) which returns sigmas in units of Angstroms.
        
        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas
        
        See notes in xsigma(...) about caching of Legendre fit coefficients.
        """

        #- First call for any spectrum: setup array to cache coefficients
        if self._ysigma is None:
            self._ysigma = [None,] * self.nspec
            
        #- First call for this spectrum: calculate coefficients & cache
        if self._ysigma[ispec] is None:
            self._ysigma[ispec] = self._fit_spot_sigma(ispec, axis=1, npoly=5)

        #- Use cached Legendre fit to interpolate xsigma at wavelength(s)
        return self._ysigma[ispec](wavelength)

    #-------------------------------------------------------------------------
    #- Cross dispersion width for row-by-row extractions
    def wdisp(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in wavelength-dispersion direction
        in units of Angstroms.
        
        Also see ysigma(...) which returns sigmas in units of pixels.
        
        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas
        
        See notes in xsigma(...) about caching of Legendre fit coefficients.
        """
        sigma_pix = self.ysigma(ispec, wavelength)
        return self.angstroms_per_pixel(ispec, wavelength) * sigma_pix        

    #-------------------------------------------------------------------------
    #- Evaluate the PSF into pixels
    
    def pix(self, ispec, wavelength):
        """
        Evaluate PSF for spectrum[ispec] at given wavelength
        
        returns 2D array pixels[iy,ix]
        
        also see xypix(ispec, wavelength)
        """
        return self.xypix(ispec, wavelength)[2]

    def _xypix(self, ispec, wavelength):
        """
        Subclasses of PSF should implement this to return
        xslice, yslice, pixels[iy,ix] for their particular
        models.  Don't worry about edge effects -- PSF.xypix
        will take care of that.
        """
        raise NotImplementedError
        
    def xypix(self, ispec, wavelength, xmin=0, xmax=None, ymin=0, ymax=None):
        """
        Evaluate PSF for spectrum[ispec] at given wavelength
        
        returns xslice, yslice, pixels[iy,ix] such that
        image[yslice,xslice] += photons*pixels adds the contribution from
        spectrum ispec at that wavelength.
        
        if xmin or ymin are set, the slices are relative to those
        minima (useful for simulating subimages)
        """
        if xmax is None:
            xmax = self.npix_x
        if ymax is None:
            ymax = self.npix_y

        if wavelength < self.wavelength(ispec, -0.5):
            return slice(0,0), slice(0,0), np.zeros((0,0))
        elif wavelength > self.wavelength(ispec, self.npix_y-0.5):
            return slice(0,0), slice(ymax, ymax), np.zeros((0,0))
        
        key = (ispec, wavelength)
        try:
            if key in self._cache:
                xx, yy, ccdpix = self._cache[key]
            else:
                xx, yy, ccdpix = self._xypix(ispec, wavelength)
                self._cache[key] = (xx, yy, ccdpix)
        except AttributeError:
            self._cache = CacheDict(2500)
            xx, yy, ccdpix = self._xypix(ispec, wavelength)
            
        xlo, xhi = xx.start, xx.stop
        ylo, yhi = yy.start, yy.stop

        #- Check if completely off the edge in any direction
        if (ylo >= ymax):
            return slice(0,0), slice(ymax,ymax), np.zeros( (0,0) )            
        elif (yhi < ymin):
            return slice(0,0), slice(ymin,ymin), np.zeros( (0,0) )
        elif (xlo >= xmax):
            return slice(xmax, xmax), slice(0,0), np.zeros( (0,0) )
        elif (xhi <= xmin):
            return slice(xmin, xmin), slice(0,0), np.zeros( (0,0) )
            
        #- Check if partially off edge
        if xlo < xmin:
            ccdpix = ccdpix[:, -(xhi-xmin):]
            xlo = xmin
        elif xhi > xmax:
            ccdpix = ccdpix[:, 0:(xmax-xlo)]
            xhi = xmax

        if ylo < ymin:
            ccdpix = ccdpix[-(yhi-ymin):, ]
            ylo = ymin
        elif yhi > ymax:
            ccdpix = ccdpix[0:(ymax-ylo), :]
            yhi = ymax
        
        xx = slice(xlo-xmin, xhi-xmin)
        yy = slice(ylo-ymin, yhi-ymin)
        
        #- Check if we are off the edge
        if (xx.stop-xx.start == 0) or (yy.stop-yy.start == 0):
            ccdpix = np.zeros( (0,0) )
                             
        return xx, yy, ccdpix

    def xyrange(self, spec_range, wavelengths):
        """
        Return recommended range of pixels which cover these spectra/fluxes:
        (xmin, xmax, ymin, ymax)
        
        spec_range = indices specmin,specmax (python style indexing),
                     or scalar for single spectrum index
        wavelengths = wavelength range wavemin,wavemax inclusive
                     or sorted array of wavelengths
        
        BUG: will fail if asking for a range where one of the spectra is
        completely off the CCD
        """
        if isinstance(spec_range, int):
            specmin, specmax = spec_range, spec_range+1
        else:
            specmin, specmax = spec_range

        if isinstance(wavelengths, (int, float)):
            wavemin = wavemax = wavelengths
        else:
            wavemin, wavemax = wavelengths[0], wavelengths[-1]
            
        if wavemin < self.wmin:
            wavemin = self.wmin
            
        if wavemax > self.wmax:
            wavemax = self.wmax
            
        #- Find the spectra with the smallest/largest y centroids
        ispec_ymin = specmin + np.argmin(self.y(None, wavemin)[specmin:specmax+1])
        ispec_ymax = specmin + np.argmax(self.y(None, wavemax)[specmin:specmax+1])
        ymin = self.xypix(ispec_ymin, wavemin)[1].start
        ymax = self.xypix(ispec_ymax, wavemax)[1].stop
                
        #- Now for wavelength where x = min(x),
        #- while staying on CCD and within wavelength range
        w = self.wavelength(specmin)
        if w[0] < wavemin:
            w = w[wavemin <= w]
        if wavemax < w[-1]:
            w = w[w <= wavemax]
        
        #- Add in wavemin and wavemax since w isn't perfect resolution
        w = np.concatenate( (w, (wavemin, wavemax) ) )
        
        #- Trim xy to where specmin is on the CCD
        #- Note: Pixel coordinates are from *center* of pixel, thus -0.5
        x, y = self.xy(specmin, w)
        onccd = (0 <= y-0.5) & (y < self.npix_y-0.5)
        x = x[onccd]
        w = w[onccd]
        if min(x) < 0:
            xmin = 0.0
        else:
            wxmin = w[np.argmin(x)]  #- wavelength at x minimum
            xmin = self.xypix(specmin, wxmin)[0].start
            
        #- and wavelength where x = max(x)
        w = self.wavelength(specmax-1)
        if w[0] < wavemin:
            w = w[wavemin <= w]
        if wavemax < w[-1]:
            w = w[w <= wavemax]
                
        #- Add in wavemin and wavemax since w isn't perfect resolution
        w = np.concatenate( (w, (wavemin, wavemax) ) )
        
        #- Trim xy to where specmax-1 is on the CCD
        #- Note: Pixel coordinates are from *center* of pixel, thus -0.5
        x, y = self.xy(specmax-1, w)
        onccd = (-0.5 <= y) & (y < self.npix_y-0.5)
        x = x[onccd]
        w = w[onccd]
        if max(x) > self.npix_x:
            xmax = self.npix_x
        else:
            wxmax = w[np.argmax(x)]
            xmax = self.xypix(specmax-1, wxmax)[0].stop
                                                                                
        return (xmin, xmax, ymin, ymax)
    
    #-------------------------------------------------------------------------
    #- Shift PSF to a new x,y grid, e.g. to account for flexure
    
    def shift_xy(self, dx, dy):
        """
        Shift the x,y trace locations of this PSF while preserving
        wavelength grid:  xnew = x + dx, ynew = y + dy
        """
        raise NotImplementedError
    
    #-------------------------------------------------------------------------
    #- accessors for x, y, wavelength
                
    def x(self, ispec=None, wavelength=None):
        """
        Return CCD X centroid of spectrum ispec at given wavelength(s).
        
        ispec can be None, scalar, or vector
        wavelength can be None, scalar or a vector
        
        ispec   wavelength  returns
        +-------+-----------+------
        None    None        array[nspec, npix_y]
        None    scalar      vector[nspec]
        None    vector      array[nspec, nwave]
        scalar  None        array[npix_y]
        scalar  scalar      scalar
        scalar  vector      vector[nwave]
        vector  None        array[nspec, npix_y]
        vector  scalar      vector[nspec]
        vector  vector      array[nspec, nwave]
        """
        
        if wavelength is None:
            #- ispec=None -> ispec=every spectrum
            if ispec is None:
                ispec = np.arange(self.nspec)
            
            #- ispec is an array; sample at every row
            if isinstance(ispec, (np.ndarray, list, tuple)):
                x = list()
                for i in ispec:
                    w = self.wavelength(i)
                    x.append(self._x.eval(i, w))
                return np.array(x)
            else:  #- scalar ispec, make wavelength an array
                wavelength = self.wavelength(ispec)
            
        return self._x.eval(ispec, wavelength)
            
    def y(self, ispec=None, wavelength=None):
        """
        Return CCD Y centroid of spectrum ispec at given wavelength(s).
        
        ispec can be None, scalar, or vector
        wavelength can be scalar or a vector (but not None)
        
        ispec   wavelength  returns
        +-------+-----------+------
        None    scalar      vector[nspec]
        None    vector      array[nspec,nwave]
        scalar  scalar      scalar
        scalar  vector      vector[nwave]
        vector  scalar      vector[nspec]
        vector  vector      array[nspec, nwave]
        """
        if wavelength is None:
            raise ValueError, "PSF.y requires wavelength scalar or vector"
            
        if ispec is None:
            ispec = np.arange(self.nspec)
            
        return self._y.eval(ispec, wavelength)
        
        if ispec is None:
            if wavelength is None:
                return np.tile(np.arange(self.npix_y), self.nspec).reshape(self.nspec, self.npix_y)
            else:
                ispec = np.arange(self.nspec)
        
        if wavelength is None:
            wavelength = self.wavelength(ispec)

        return self._y.eval(ispec, wavelength)
            
    def xy(self, ispec=None, wavelength=None):
        """
        Utility function to return self.x(...) and self.y(...) in one call
        """
        x = self.x(ispec, wavelength)
        y = self.y(ispec, wavelength)
        return x, y

    def wavelength(self, ispec=None, y=None):
        """
        Return wavelength of spectrum[ispec] evaluated at y.
        
        ispec can be None, scalar, or vector
        y can be None, scalar, or vector

        May return a view of the underlying array; do not modify unless
        specifying copy=True to get a copy of the data.
        """
        if y is None:
            y = np.arange(0, self.npix_y)
        
        if ispec is None:
            ispec = np.arange(self.nspec)
            
        return self._w.eval(ispec, y)
    
    def angstroms_per_pixel(self, ispec, wavelength):
        """
        Return CCD pixel width in Angstroms for spectrum ispec at given
        wavlength(s).  Wavelength may be scalar or array.
        """
        ww = self.wavelength(ispec, y=np.arange(self.npix_y))
        dw = np.gradient( ww )
        return np.interp(wavelength, ww, dw)
    
    #-------------------------------------------------------------------------
    #- Project spectra onto CCD pixels
    # def project_subimage(self, phot, wavelength, specmin, verbose=False):
    #     """
    #     Project photons onto CCD.  Returns subimage, (xmin,xmax,ymin,ymax).
    #     See PSF.project() for full parameter descriptions.
    #     """
    #     #- NOTES:
    #     #- Tightly coupled to self.project
    #     #- Should this return slices instead of xyrange, similar to
    #     #-     PSF.xypix?
    #     #- Maybe even rename to xyproject() ?
    #     
    #     nspec = phot.shape[0] if phot.ndim == 2 else self.nspec
    #     specmax = min(specmin+nspec, nspec)
    #     specrange = (specmin, specmax)
    #     waverange = (np.min(wavelength), np.max(wavelegth))
    #     xmin, xmax, ymin, ymax = xyrange = self.xyrange(specrange, waverange)
    #     image = self.project(wavelength, phot, specmin=specmin, \
    #         xr=(xmin,xmax), yr=(ymin, ymax), verbose=verbose)
    #         
    #     return image, xyrange

    def project(self, wavelength, phot, specmin=0, xyrange=None, verbose=False):
        """
        Returns 2D image of spectra projected onto the CCD

        Required inputs:
            phot[nwave] or phot[nspec, nwave] as photons on CCD per bin
            wavelength[nwave] or wavelength[nspec, nwave] in Angstroms
                if wavelength is 1D and spectra is 2D, then wavelength[]
                applies to all phot[i]

        Optional inputs:
            specmin : starting spectrum number
            xyrange : (xmin, xmax, ymin, ymax) range of CCD pixels
        """
        wavelength = np.asarray(wavelength)
        phot = np.asarray(phot)
        if specmin >= self.nspec:
            raise ValueError('specmin {} >= psf.nspec {}'.format(specmin, self.nspec))
        if specmin+phot.shape[0] > self.nspec:
            print >> sys.stderr, "WARNING: specmin+npec ({}+{}) > psf.nspec {}".format(specmin, phot.shape[0], self.nspec)
        
        #- x,y ranges and number of pixels
        if xyrange is None:
            xmin, xmax = (0, self.npix_x)
            ymin, ymax = (0, self.npix_y)
            xyrange = (xmin, xmax, ymin, ymax)
        else:
            xmin, xmax, ymin, ymax = xyrange
            
        nx = xmax - xmin
        ny = ymax - ymin

        #- For convenience, treat phot as a 2D vector
        phot = np.atleast_2d(phot)
        nspec, nw = phot.shape

        #- Create image to fill
        img = np.zeros( (ny, nx) )

        #- Loop over spectra and wavelengths
        specmax = min(specmin+nspec, self.nspec)
        for i, ispec in enumerate(range(specmin, specmax)):
            if verbose:
                print ispec
            
            #- 1D wavelength for every spec, or 2D wavelength for 2D phot?
            if wavelength.ndim == 2:
                wspec = wavelength[i]
            else:
                wspec = wavelength
                
            #- Evaluate positive photons within wavelength range
            wmin, wmax = self.wavelength(ispec, y=(0, self.npix_y))
            for j, w in enumerate(wspec):
                if phot[i,j] > 0.0 and (wmin <= w <= wmax):
                    xx, yy, pix = self.xypix(ispec, w, \
                        xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)
                    if (xx.stop > xx.start) and (yy.stop > yy.start):
                        img[yy, xx] += pix * phot[i,j]

        return img
    
    #- Convenience functions
    
    @property
    def wmin(self):
        """Minimum wavelength seen by any spectrum"""
        return self._wmin

    @property
    def wmax(self):
        """Maximum wavelength seen by any spectrum"""
        return self._wmax
    
    @property
    def wmin_all(self):
        """Minimum wavelength seen by all spectra"""
        return self._wmin_all

    @property
    def wmax_all(self):
        """Maximum wavelength seen by all spectra"""
        return self._wmax_all
    
    def projection_matrix(self, spec_range, wavelengths, xyrange):
        """
        Returns sparse projection matrix from flux to pixels
    
        Inputs:
            spec_range = (ispecmin, ispecmax) or scalar ispec
            wavelengths = array_like wavelengths
            xyrange  = (xmin, xmax, ymin, ymax)
            
        Usage:
            xyrange = xmin, xmax, ymin, ymax
            A = psf.projection_matrix(spec_range, wavelengths, xyrange)
            nx = xmax-xmin
            ny = ymax-ymin
            img = A.dot(phot.ravel()).reshape((ny,nx))
        """
    
        #- Matrix dimensions
        if isinstance(spec_range, int):
            specmin, specmax = spec_range, spec_range+1
        else:
            specmin, specmax = spec_range
            
        xmin, xmax, ymin, ymax = xyrange        
        nspec = specmax - specmin
        nflux = len(wavelengths)
        nx = xmax - xmin
        ny = ymax - ymin
    
        #- Generate A
        A = np.zeros( (ny*nx, nspec*nflux) )
        tmp = np.zeros((ny, nx))
        for ispec in range(specmin, specmax):
            for iflux, w in enumerate(wavelengths):
                #- Get subimage and index slices
                xslice, yslice, pix = self.xypix(ispec, w, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)
                
                #- If there is overlap with pix_range, put into sub-region of A
                if pix.shape[0]>0 and pix.shape[1]>0:         
                    tmp[yslice, xslice] = pix
                    ij = (ispec-specmin)*nflux + iflux
                    A[:, ij] = tmp.ravel()
                    tmp[yslice, xslice] = 0.0
        
        return scipy.sparse.csr_matrix(A)    
Пример #5
0
class PSF(object):
    """
    Base class for 2D PSFs

    Subclasses need to extend __init__ to load format-specific items
    from the input fits file and implement _xypix(ispec, wavelength)
    to return xslice, yslice, pixels[y,x] for the PSF evaluated at
    spectrum ispec at the given wavelength.  All interactions with PSF
    classes should be via the methods defined here, allowing
    interchangeable use of different PSF models.
    """
    def __init__(self, filename):
        """
        Load PSF parameters from a file

        Loads x, y, wavelength information for spectral traces and fills:
            self.npix_x   #- number of columns in the target image
            self.npix_y   #- number of rows in the target image
            self.nspec    #- number of spectra (fibers)
            self.nwave    #- number of wavelength samples per spectrum

        Subclasses of this class define the xypix(ispec, wavelength) method
        to access the projection of this PSF into pixels.
        """

        #- Load basic dimensions
        hdr = fits.getheader(filename)
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']
        self.nspec = hdr['NSPEC']

        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load x, y legendre coefficient tracesets
        with fits.open(filename) as fx:
            xc = fx['XCOEFF'].data
            hdr = fx['XCOEFF'].header
            self._x = TraceSet(xc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))
            yc = fx['YCOEFF'].data
            hdr = fx['YCOEFF'].header
            self._y = TraceSet(yc, domain=(hdr['WAVEMIN'], hdr['WAVEMAX']))

        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()

        #- Cache min/max wavelength per fiber at pixel edges
        self._wmin_spec = self.wavelength(None, -0.5)
        self._wmax_spec = self.wavelength(None, self.npix_y - 0.5)
        self._wmin = np.min(self._wmin_spec)
        self._wmin_all = np.max(self._wmin_spec)
        self._wmax = np.max(self._wmax_spec)
        self._wmax_all = np.min(self._wmax_spec)

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None

    #- Utility function to fit spot sigma vs. wavelength
    def _fit_spot_sigma(self, ispec, axis=0, npoly=5):
        """
        Fit the cross-sectional Gaussian sigma of PSF spots vs. wavelength.
        Return callable Legendre object.

        Arguments:
            ispec : spectrum number
            axis  : 0 or 'x' for cross dispersion sigma;
                    1 or 'y' or 'w' for wavelength dispersion
            npoly : order of Legendre poly to fit to sigma vs. wavelength

        Returns:
            legfit such that legfit(w) returns fit at wavelengths w
        """

        if type(axis) is not int:
            if axis in ('x', 'X'):
                axis = 0
            elif axis in ('y', 'Y', 'w', 'W'):
                axis = 1
            else:
                raise ValueError("Unknown axis type {}".format(axis))

        if axis not in (0, 1):
            raise ValueError("axis must be 0, 'x', 1, 'y', or 'w'")

        yy = np.linspace(10, self.npix_y - 10, 20)
        ww = self.wavelength(ispec, y=yy)
        xsig = list()  #- sigma vs. wavelength array to fill
        for w in ww:
            xspot = self.pix(ispec, w).sum(axis=axis)
            xspot /= np.sum(xspot)  #- normalize for edge cases
            xx = np.arange(len(xspot))
            mean, sigma = scipy.optimize.curve_fit(gausspix, xx, xspot)[0]

            xsig.append(sigma)

        #- Fit Legendre polynomial and return coefficients
        legfit = Legendre.fit(ww, xsig, npoly, domain=(self._wmin, self._wmax))

        return legfit

    #-------------------------------------------------------------------------
    #- Cross dispersion width for row-by-row extractions
    def xsigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in cross-dispersion direction
        in CCD pixel units.

        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas

        The first time this is called for a spectrum, the PSF is sampled
        at 20 wavelengths and the variation is fit with a 5th order
        Legendre polynomial and the coefficients are cached.
        The actual value (and subsequent calls) use these cached
        Legendre fits to interpolate the sigma value.  If this is not
        fast enough and/or accurate enough, PSF subtypes may override
        this function to provide a more accurate xsigma measurement.
        """

        #- First call for any spectrum: setup array to cache coefficients
        if self._xsigma is None:
            self._xsigma = [
                None,
            ] * self.nspec

        #- First call for this spectrum: calculate coefficients & cache
        if self._xsigma[ispec] is None:
            self._xsigma[ispec] = self._fit_spot_sigma(ispec, axis=0, npoly=5)

        #- Use cached Legendre fit to interpolate xsigma at wavelength(s)
        return self._xsigma[ispec](wavelength)

    #-------------------------------------------------------------------------
    #- Cross dispersion width for row-by-row extractions
    def ysigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in wavelength-dispersion direction
        in units of pixels.

        Also see wdisp(...) which returns sigmas in units of Angstroms.

        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas

        See notes in xsigma(...) about caching of Legendre fit coefficients.
        """

        #- First call for any spectrum: setup array to cache coefficients
        if self._ysigma is None:
            self._ysigma = [
                None,
            ] * self.nspec

        #- First call for this spectrum: calculate coefficients & cache
        if self._ysigma[ispec] is None:
            self._ysigma[ispec] = self._fit_spot_sigma(ispec, axis=1, npoly=5)

        #- Use cached Legendre fit to interpolate xsigma at wavelength(s)
        return self._ysigma[ispec](wavelength)

    #-------------------------------------------------------------------------
    #- Cross dispersion width for row-by-row extractions
    def wdisp(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in wavelength-dispersion direction
        in units of Angstroms.

        Also see ysigma(...) which returns sigmas in units of pixels.

        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas

        See notes in xsigma(...) about caching of Legendre fit coefficients.
        """
        sigma_pix = self.ysigma(ispec, wavelength)
        return self.angstroms_per_pixel(ispec, wavelength) * sigma_pix

    #-------------------------------------------------------------------------
    #- Evaluate the PSF into pixels

    def pix(self, ispec, wavelength):
        """
        Evaluate PSF for spectrum[ispec] at given wavelength

        returns 2D array pixels[iy,ix]

        also see xypix(ispec, wavelength)
        """
        return self.xypix(ispec, wavelength)[2]

    def _xypix(self, ispec, wavelength, ispec_cache=None, iwave_cache=None):
        """
        Subclasses of PSF should implement this to return
        xslice, yslice, pixels[iy,ix] for their particular
        models.  Don't worry about edge effects -- PSF.xypix
        will take care of that.
        """
        raise NotImplementedError

    def xypix(self,
              ispec,
              wavelength,
              xmin=0,
              xmax=None,
              ymin=0,
              ymax=None,
              ispec_cache=None,
              iwave_cache=None):
        """
        Evaluate PSF for spectrum[ispec] at given wavelength

        returns xslice, yslice, pixels[iy,ix] such that
        image[yslice,xslice] += photons*pixels adds the contribution from
        spectrum ispec at that wavelength.

        if xmin or ymin are set, the slices are relative to those
        minima (useful for simulating subimages)

        Optional inputs:
            ispec_cache = an index into the spectrum number that starts again at 0 for each patch
            iwave_cache = an index into the wavelength number that starts again at 0 for each patch
        """
        if xmax is None:
            xmax = self.npix_x
        if ymax is None:
            ymax = self.npix_y

        if wavelength < self._wmin_spec[ispec]:
            return slice(0, 0), slice(0, 0), np.zeros((0, 0))
        elif wavelength > self._wmax_spec[ispec]:
            return slice(0, 0), slice(ymax, ymax), np.zeros((0, 0))

        key = (ispec, wavelength)
        try:
            if key in self._cache:
                xx, yy, ccdpix = self._cache[key]
            else:
                xx, yy, ccdpix = self._xypix(ispec,
                                             wavelength,
                                             ispec_cache=ispec_cache,
                                             iwave_cache=iwave_cache)
                self._cache[key] = (xx, yy, ccdpix)
        except AttributeError:
            self._cache = CacheDict(2500)
            xx, yy, ccdpix = self._xypix(ispec,
                                         wavelength,
                                         ispec_cache=ispec_cache,
                                         iwave_cache=iwave_cache)

        xlo, xhi = xx.start, xx.stop
        ylo, yhi = yy.start, yy.stop

        #- Check if completely off the edge in any direction
        if (ylo >= ymax):
            return slice(0, 0), slice(ymax, ymax), np.zeros((0, 0))
        elif (yhi < ymin):
            return slice(0, 0), slice(ymin, ymin), np.zeros((0, 0))
        elif (xlo >= xmax):
            return slice(xmax, xmax), slice(0, 0), np.zeros((0, 0))
        elif (xhi <= xmin):
            return slice(xmin, xmin), slice(0, 0), np.zeros((0, 0))

        #- Check if partially off edge
        if xlo < xmin:
            ccdpix = ccdpix[:, -(xhi - xmin):]
            xlo = xmin
        elif xhi > xmax:
            ccdpix = ccdpix[:, 0:(xmax - xlo)]
            xhi = xmax

        if ylo < ymin:
            ccdpix = ccdpix[-(yhi - ymin):, ]
            ylo = ymin
        elif yhi > ymax:
            ccdpix = ccdpix[0:(ymax - ylo), :]
            yhi = ymax

        xx = slice(xlo - xmin, xhi - xmin)
        yy = slice(ylo - ymin, yhi - ymin)

        #- Check if we are off the edge
        if (xx.stop - xx.start == 0) or (yy.stop - yy.start == 0):
            ccdpix = np.zeros((0, 0))

        return xx, yy, ccdpix

    def xyrange(self, spec_range, wavelengths):
        """
        Return recommended range of pixels which cover these spectra/fluxes:
        (xmin, xmax, ymin, ymax)

        spec_range = indices specmin,specmax (python style indexing),
                     or scalar for single spectrum index
        wavelengths = wavelength range wavemin,wavemax inclusive
                     or sorted array of wavelengths

        BUG: will fail if asking for a range where one of the spectra is
        completely off the CCD
        """
        if isinstance(spec_range, numbers.Integral):
            specmin, specmax = spec_range, spec_range + 1
        else:
            specmin, specmax = spec_range

        if isinstance(wavelengths, numbers.Real):
            wavemin = wavemax = wavelengths
        else:
            wavemin, wavemax = wavelengths[0], wavelengths[-1]

        if wavemin < self.wmin:
            wavemin = self.wmin

        if wavemax > self.wmax:
            wavemax = self.wmax

        #- Find the spectra with the smallest/largest y centroids
        ispec_ymin = specmin + np.argmin(
            self.y(None, wavemin)[specmin:specmax + 1])
        ispec_ymax = specmin + np.argmax(
            self.y(None, wavemax)[specmin:specmax + 1])
        ymin = self.xypix(ispec_ymin, wavemin)[1].start
        ymax = self.xypix(ispec_ymax, wavemax)[1].stop

        #- Now for wavelength where x = min(x),
        #- while staying on CCD and within wavelength range
        w = self.wavelength(specmin)
        if w[0] < wavemin:
            w = w[wavemin <= w]
        if wavemax < w[-1]:
            w = w[w <= wavemax]

        #- Add in wavemin and wavemax since w isn't perfect resolution
        w = np.concatenate((w, (wavemin, wavemax)))

        #- Trim xy to where specmin is on the CCD
        #- Note: Pixel coordinates are from *center* of pixel, thus -0.5
        x, y = self.xy(specmin, w)
        onccd = (0 <= y - 0.5) & (y < self.npix_y - 0.5)
        x = x[onccd]
        w = w[onccd]
        if min(x) < 0:
            xmin = 0.0
        else:
            wxmin = w[np.argmin(x)]  #- wavelength at x minimum
            xmin = self.xypix(specmin, wxmin)[0].start

        #- and wavelength where x = max(x)
        w = self.wavelength(specmax - 1)
        if w[0] < wavemin:
            w = w[wavemin <= w]
        if wavemax < w[-1]:
            w = w[w <= wavemax]

        #- Add in wavemin and wavemax since w isn't perfect resolution
        w = np.concatenate((w, (wavemin, wavemax)))

        #- Trim xy to where specmax-1 is on the CCD
        #- Note: Pixel coordinates are from *center* of pixel, thus -0.5
        x, y = self.xy(specmax - 1, w)
        onccd = (-0.5 <= y) & (y < self.npix_y - 0.5)
        x = x[onccd]
        w = w[onccd]
        if max(x) > self.npix_x:
            xmax = self.npix_x
        else:
            wxmax = w[np.argmax(x)]
            xmax = self.xypix(specmax - 1, wxmax)[0].stop

        return (xmin, xmax, ymin, ymax)

    #-------------------------------------------------------------------------
    #- Shift PSF to a new x,y grid, e.g. to account for flexure

    def shift_xy(self, dx, dy):
        """
        Shift the x,y trace locations of this PSF while preserving
        wavelength grid:  xnew = x + dx, ynew = y + dy
        """
        raise NotImplementedError

    #-------------------------------------------------------------------------
    #- accessors for x, y, wavelength

    def x(self, ispec=None, wavelength=None):
        """
        Return CCD X centroid of spectrum ispec at given wavelength(s).

        ispec can be None, scalar, or vector
        wavelength can be None, scalar or a vector

        ispec   wavelength  returns
        +-------+-----------+------
        None    None        array[nspec, npix_y]
        None    scalar      vector[nspec]
        None    vector      array[nspec, nwave]
        scalar  None        array[npix_y]
        scalar  scalar      scalar
        scalar  vector      vector[nwave]
        vector  None        array[nspec, npix_y]
        vector  scalar      vector[nspec]
        vector  vector      array[nspec, nwave]
        """

        if wavelength is None:
            #- ispec=None -> ispec=every spectrum
            if ispec is None:
                ispec = np.arange(self.nspec, dtype=int)

            #- ispec is an array; sample at every row
            if isinstance(ispec, (np.ndarray, list, tuple)):
                x = list()
                for i in ispec:
                    w = self.wavelength(i)
                    x.append(self._x.eval(i, w))
                return np.array(x)
            else:  #- scalar ispec, make wavelength an array
                wavelength = self.wavelength(ispec)

        return self._x.eval(ispec, wavelength)

    def y(self, ispec=None, wavelength=None):
        """
        Return CCD Y centroid of spectrum ispec at given wavelength(s).

        ispec can be None, scalar, or vector
        wavelength can be scalar or a vector (but not None)

        ispec   wavelength  returns
        +-------+-----------+------
        None    scalar      vector[nspec]
        None    vector      array[nspec,nwave]
        scalar  scalar      scalar
        scalar  vector      vector[nwave]
        vector  scalar      vector[nspec]
        vector  vector      array[nspec, nwave]
        """
        if wavelength is None:
            raise ValueError("PSF.y requires wavelength scalar or vector")

        if ispec is None:
            ispec = np.arange(self.nspec)

        return self._y.eval(ispec, wavelength)

        if ispec is None:
            if wavelength is None:
                return np.tile(np.arange(self.npix_y),
                               self.nspec).reshape(self.nspec, self.npix_y)
            else:
                ispec = np.arange(self.nspec, dtype=int)

        if wavelength is None:
            wavelength = self.wavelength(ispec)

        return self._y.eval(ispec, wavelength)

    def xy(self, ispec=None, wavelength=None):
        """
        Utility function to return self.x(...) and self.y(...) in one call
        """
        x = self.x(ispec, wavelength)
        y = self.y(ispec, wavelength)
        return x, y

    def wavelength(self, ispec=None, y=None):
        """
        Return wavelength of spectrum[ispec] evaluated at y.

        ispec can be None, scalar, or vector
        y can be None, scalar, or vector

        May return a view of the underlying array; do not modify unless
        specifying copy=True to get a copy of the data.
        """
        if y is None:
            y = np.arange(0, self.npix_y)

        if ispec is None:
            ispec = np.arange(self.nspec, dtype=int)

        return self._w.eval(ispec, y)

    def angstroms_per_pixel(self, ispec, wavelength):
        """
        Return CCD pixel width in Angstroms for spectrum ispec at given
        wavlength(s).  Wavelength may be scalar or array.
        """
        ww = self.wavelength(ispec, y=np.arange(self.npix_y))
        dw = np.gradient(ww)
        return np.interp(wavelength, ww, dw)

    #-------------------------------------------------------------------------
    #- Project spectra onto CCD pixels
    # def project_subimage(self, phot, wavelength, specmin, verbose=False):
    #     """
    #     Project photons onto CCD.  Returns subimage, (xmin,xmax,ymin,ymax).
    #     See PSF.project() for full parameter descriptions.
    #     """
    #     #- NOTES:
    #     #- Tightly coupled to self.project
    #     #- Should this return slices instead of xyrange, similar to
    #     #-     PSF.xypix?
    #     #- Maybe even rename to xyproject() ?
    #
    #     nspec = phot.shape[0] if phot.ndim == 2 else self.nspec
    #     specmax = min(specmin+nspec, nspec)
    #     specrange = (specmin, specmax)
    #     waverange = (np.min(wavelength), np.max(wavelegth))
    #     xmin, xmax, ymin, ymax = xyrange = self.xyrange(specrange, waverange)
    #     image = self.project(wavelength, phot, specmin=specmin, \
    #         xr=(xmin,xmax), yr=(ymin, ymax), verbose=verbose)
    #
    #     return image, xyrange

    def project(self,
                wavelength,
                phot,
                specmin=0,
                xyrange=None,
                verbose=False):
        """
        Returns 2D image or 3D images of spectra projected onto the CCD

        Required inputs:
            phot[nwave] or phot[nspec, nwave] or phot[nimage, nspec, nwave]
                as photons on CCD per bin
            wavelength[nwave] or wavelength[nspec, nwave] in Angstroms
                if wavelength is 1D and spectra is 2D or 3D, then wavelength[]
                applies to all phot[i]

        Optional inputs:
            specmin : starting spectrum number
            xyrange : (xmin, xmax, ymin, ymax) range of CCD pixels

        if phot is 1D or 2D, output is a single 2D[ny,nx] image
        if phot is 3D[nimage,nspec,nwave], output is 3D[nimage,ny,nx]
        """
        wavelength = np.asarray(wavelength)
        phot = np.asarray(phot)
        if specmin >= self.nspec:
            raise ValueError('specmin {} >= psf.nspec {}'.format(
                specmin, self.nspec))
        if phot.shape[-1] != wavelength.shape[-1]:
            raise ValueError(
                'phot.shape {} vs. wavelength.shape {} mismatch'.format(
                    phot.shape, wavelength.shape))

        #- x,y ranges and number of pixels
        if xyrange is None:
            xmin, xmax = (0, self.npix_x)
            ymin, ymax = (0, self.npix_y)
            xyrange = (xmin, xmax, ymin, ymax)
        else:
            xmin, xmax, ymin, ymax = xyrange

        nx = xmax - xmin
        ny = ymax - ymin

        #- convert phot to 3D[nimage, nspec, nwave]
        phot = np.atleast_2d(phot)
        if phot.ndim == 3:
            nimage, nspec, nw = phot.shape
            singleimage = False
        else:
            nspec, nw = phot.shape
            nimage = 1
            phot = phot.reshape(nimage, nspec, nw)
            singleimage = True

        if specmin + nspec > self.nspec:
            print("WARNING: specmin+nspec ({}+{}) > psf.nspec {}".format(
                specmin, nspec, self.nspec),
                  file=sys.stderr)

        #- Create image to fill
        img = np.zeros((nimage, ny, nx))

        #- Loop over spectra and wavelengths
        specmax = min(specmin + nspec, self.nspec)
        for i, ispec in enumerate(range(specmin, specmax)):
            if verbose:
                print(ispec)

            #- 1D wavelength for every spec, or 2D wavelength for 2D phot?
            if wavelength.ndim == 2:
                wspec = wavelength[i]
            else:
                wspec = wavelength

            #- Evaluate positive photons within wavelength range
            wmin, wmax = self.wavelength(ispec, y=(0, self.npix_y))
            for j, w in enumerate(wspec):
                if np.any(phot[:, i, j] > 0.0) and (wmin <= w <= wmax):
                    xx, yy, pix = self.xypix(ispec, w, \
                        xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)
                    if (xx.stop > xx.start) and (yy.stop > yy.start):
                        for k in range(nimage):
                            img[k, yy, xx] += pix * phot[k, i, j]

        if singleimage:
            return img[0]
        else:
            return img

    #- Convenience functions

    @property
    def wmin(self):
        """Minimum wavelength seen by any spectrum"""
        return self._wmin

    @property
    def wmax(self):
        """Maximum wavelength seen by any spectrum"""
        return self._wmax

    @property
    def wmin_all(self):
        """Minimum wavelength seen by all spectra"""
        return self._wmin_all

    @property
    def wmax_all(self):
        """Maximum wavelength seen by all spectra"""
        return self._wmax_all

    def projection_matrix(self,
                          spec_range,
                          wavelengths,
                          xyrange,
                          use_cache=None):
        """
        Returns sparse projection matrix from flux to pixels

        Inputs:
            spec_range = (ispecmin, ispecmax) or scalar ispec
            wavelengths = array_like wavelengths
            xyrange  = (xmin, xmax, ymin, ymax)

        Optional inputs:
            use_cache= default True, legval values will be precomputed

        Usage:
            xyrange = xmin, xmax, ymin, ymax
            A = psf.projection_matrix(spec_range, wavelengths, xyrange)
            nx = xmax-xmin
            ny = ymax-ymin
            img = A.dot(phot.ravel()).reshape((ny,nx))
        """

        #- Matrix dimensions
        if isinstance(spec_range, numbers.Integral):
            specmin, specmax = spec_range, spec_range + 1
        else:
            specmin, specmax = spec_range

        xmin, xmax, ymin, ymax = xyrange
        nspec = specmax - specmin
        nflux = len(wavelengths)
        nx = xmax - xmin
        ny = ymax - ymin

        if use_cache:
            self.cache_params(spec_range, wavelengths)
        else:
            #make sure legval_dict is empty if we're not using it
            self.legval_dict = None

        #- Generate A
        #- Start with a transposed version to fill it more efficiently
        A = np.zeros((nspec * nflux, ny * nx))
        tmp = np.zeros((ny, nx))
        for ispec_cache, ispec in enumerate(range(specmin, specmax)):
            for iflux, w in enumerate(wavelengths):
                #- Get subimage and index slices
                #have to keep track of an extra set of indicides if we're using cached values
                #i.e. they have to start over again in the patch
                xslice, yslice, pix = self.xypix(ispec,
                                                 w,
                                                 xmin=xmin,
                                                 xmax=xmax,
                                                 ymin=ymin,
                                                 ymax=ymax,
                                                 ispec_cache=ispec_cache,
                                                 iwave_cache=iflux)

                #- If there is overlap with pix_range, put into sub-region of A
                if pix.shape[0] > 0 and pix.shape[1] > 0:
                    tmp[yslice, xslice] = pix
                    ij = (ispec - specmin) * nflux + iflux
                    A[ij, :] = tmp.ravel()
                    tmp[yslice, xslice] = 0.0

        #when we are finished with legval_dict clear it out
        #this is important so we don't enter the cached branch of _xypix at the wrong time
        self.legval_dict = None

        return scipy.sparse.csr_matrix(A.T)

    def cache_params(self, spec_range, wavelengths):
        """
        this is implemented in specter.psf.gausshermite, everywhere else just an empty function
        """
        pass

    def _value(self, x, y, ispec, wavelength):
        """
        this is implemented in specter.psf.gausshermite and specter.psf.spotgrid,
        everywhere else just an empty function
        """
        pass
Пример #6
0
    def __init__(self, filename):
        """
        Initialize GaussHermitePSF from input file
        """
        #- Check that this file is a current generation Gauss Hermite PSF
        fx = fits.open(filename, memmap=False)
        self._polyparams = hdr = fx[1].header
        if 'PSFTYPE' not in hdr:
            raise ValueError('Missing PSFTYPE keyword')

        if hdr['PSFTYPE'] != 'GAUSS-HERMITE2':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(hdr['PSFTYPE']))

        if 'PSFVER' not in hdr:
            raise ValueError("PSFVER missing; this version not supported")

        if hdr['PSFVER'] < '1':
            raise ValueError("Only GAUSS-HERMITE versions 1.0 and greater are supported")

        #- Calculate number of spectra from FIBERMIN and FIBERMAX (inclusive)
        self.nspec = hdr['FIBERMAX'] - hdr['FIBERMIN'] + 1

        #- Other necessary keywords
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']

        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load the parameters into self.coeff dictionary keyed by PARAM
        #- with values as TraceSets for evaluating the Legendre coefficients
        data = fx[1].data
        self.coeff = dict()
        for p in data:
            domain = (p['WAVEMIN'], p['WAVEMAX'])
            for p in data:
                name = p['PARAM'].strip()
                self.coeff[name] = TraceSet(p['COEFF'], domain=domain)

        #- Pull out x and y as special tracesets
        self._x = self.coeff['X']
        self._y = self.coeff['Y']

        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()

        #- Cache min/max wavelength per fiber at pixel edges
        self._wmin_spec = self.wavelength(None, -0.5)
        self._wmax_spec = self.wavelength(None, self.npix_y-0.5)
        self._wmin = np.min(self._wmin_spec)
        self._wmin_all = np.max(self._wmin_spec)
        self._wmax = np.max(self._wmax_spec)
        self._wmax_all = np.min(self._wmax_spec)

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None

        #- Cache hermitenorm polynomials so we don't have to create them
        #- every time xypix is called
        self._hermitenorm = list()
        maxdeg = max(hdr['GHDEGX'], hdr['GHDEGY'], hdr['GHDEGX2'], hdr['GHDEGY2'])
        for i in range(maxdeg+1):
            self._hermitenorm.append( sp.hermitenorm(i) )

        fx.close()
Пример #7
0
class GaussHermitePSF(PSF):
    """
    Model PSF with two central Gauss-Hermite cores with different sigmas
    plus power law wings.
    """
    def __init__(self, filename):
        """
        Initialize GaussHermitePSF from input file
        """
        #- Check that this file is a current generation Gauss Hermite PSF
        fx = fits.open(filename, memmap=False)

        #- Read primary header
        phdr = fx[0].header
        if 'PSFTYPE' not in phdr:
            raise ValueError('Missing PSFTYPE keyword')
        if phdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(
                phdr['PSFTYPE']))
        if 'PSFVER' not in phdr:
            raise ValueError("PSFVER missing; this version not supported")
        PSFVER = float(phdr["PSFVER"])

        if PSFVER < 3:
            psf_hdu = 1
        else:
            psf_hdu = "PSF"

        self._polyparams = hdr = dict(fx[psf_hdu].header)
        if 'PSFTYPE' not in hdr:
            raise ValueError('Missing PSFTYPE keyword')

        if hdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(
                hdr['PSFTYPE']))

        if 'PSFVER' not in hdr:
            raise ValueError("PSFVER missing; this version not supported")

        if hdr['PSFVER'] < '1':
            raise ValueError(
                "Only GAUSS-HERMITE versions 1.0 and greater are supported")

        #- Calculate number of spectra from FIBERMIN and FIBERMAX (inclusive)
        self.nspec = hdr['FIBERMAX'] - hdr['FIBERMIN'] + 1

        #- Other necessary keywords
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']

        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load the parameters into self.coeff dictionary keyed by PARAM
        #- with values as TraceSets for evaluating the Legendre coefficients
        data = fx[psf_hdu].data
        self.coeff = dict()
        if PSFVER < 3:  # old format

            for p in data:
                domain = (p['WAVEMIN'], p['WAVEMAX'])
                for p in data:
                    name = p['PARAM'].strip()
                    self.coeff[name] = TraceSet(p['COEFF'], domain=domain)

            #- Pull out x and y as special tracesets
            self._x = self.coeff['X']
            self._y = self.coeff['Y']

        else:  # new format

            domain = (hdr['WAVEMIN'], hdr['WAVEMAX'])
            for p in data:
                name = p['PARAM'].strip()
                self.coeff[name] = TraceSet(p['COEFF'], domain=domain)

            self._x = TraceSet(fx["XTRACE"].data,
                               domain=(fx['XTRACE'].header["WAVEMIN"],
                                       fx['XTRACE'].header['WAVEMAX']))
            self._y = TraceSet(fx["YTRACE"].data,
                               domain=(fx['YTRACE'].header["WAVEMIN"],
                                       fx['YTRACE'].header['WAVEMAX']))

        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()

        #- Cache min/max wavelength per fiber at pixel edges
        self._wmin_spec = self.wavelength(None, -0.5)
        self._wmax_spec = self.wavelength(None, self.npix_y - 0.5)
        self._wmin = np.min(self._wmin_spec)
        self._wmin_all = np.max(self._wmin_spec)
        self._wmax = np.max(self._wmax_spec)
        self._wmax_all = np.min(self._wmax_spec)

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None

        #create dict to hold legval cached data
        self.legval_dict = None

        #- Cache hermitenorm polynomials so we don't have to create them
        #- every time xypix is called
        self._hermitenorm = list()
        maxdeg = max(hdr['GHDEGX'], hdr['GHDEGY'])
        for i in range(maxdeg + 1):
            self._hermitenorm.append(sp.hermitenorm(i))

        fx.close()

    def _xypix(self, ispec, wavelength, ispec_cache=None, iwave_cache=None):
        """
        Two branches of this function which does legendre series fitting
        First branch = no caching, will recompute legval every time eval is used (slow)
        Second branch = yes caching, will look up precomputed values of legval (faster)

        Arguments:
            ispec: the index of each spectrum
            wavelength: the wavelength at which to evaluate the legendre series

        Optional arguments:
            ispec_cache: the index of each spectrum which starts again at 0 for each patch
            iwave_cache: the index of each wavelength which starts again at 0 for each patch
        """

        #trying to avoid duplicating code between branches, will split into
        #cached branch and non-cached branch depending on self.legval_dict

        #we need this for the original indexing so skip looking up cached values here
        x = self._x.eval(ispec, wavelength)
        y = self._y.eval(ispec, wavelength)

        #- CCD pixel ranges
        hsizex = self._polyparams['HSIZEX']
        hsizey = self._polyparams['HSIZEY']
        xccd = np.arange(int(x - hsizex + 0.5), int(x + hsizex + 1.5))
        yccd = np.arange(int(y - hsizey + 0.5), int(y + hsizey + 1.5))

        dx = xccd - x
        dy = yccd - y
        nx = len(dx)
        ny = len(dy)

        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']

        if self.legval_dict is None:
            #non-cached branch
            #print("self.legval_dict is None, hitting non-cached branch")

            #- Extract GH degree and sigma coefficients for convenience
            sigx1 = self.coeff['GHSIGX'].eval(ispec, wavelength)
            sigy1 = self.coeff['GHSIGY'].eval(ispec, wavelength)

            #- Background tail image
            tailxsca = self.coeff['TAILXSCA'].eval(ispec, wavelength)
            tailysca = self.coeff['TAILYSCA'].eval(ispec, wavelength)
            tailamp = self.coeff['TAILAMP'].eval(ispec, wavelength)
            tailcore = self.coeff['TAILCORE'].eval(ispec, wavelength)
            tailinde = self.coeff['TAILINDE'].eval(ispec, wavelength)

        else:
            #cached branch
            #print("self.legval_dict is not None, hitting cached branch")

            #- Extract GH degree and sigma coefficients for convenience
            sigx1 = self.legval_dict['GHSIGX'][ispec_cache, iwave_cache]
            sigy1 = self.legval_dict['GHSIGY'][ispec_cache, iwave_cache]

            #- Background tail image
            tailxsca = self.legval_dict['TAILXSCA'][ispec_cache, iwave_cache]
            tailysca = self.legval_dict['TAILYSCA'][ispec_cache, iwave_cache]
            tailamp = self.legval_dict['TAILAMP'][ispec_cache, iwave_cache]
            tailcore = self.legval_dict['TAILCORE'][ispec_cache, iwave_cache]
            tailinde = self.legval_dict['TAILINDE'][ispec_cache, iwave_cache]

        #- Make tail image (slow version)
        # img = np.zeros((len(yccd), len(xccd)))
        # for i, dyy in enumerate(dy):
        #     for j, dxx in enumerate(dx):
        #         r2 = (dxx*tailxsca)**2 + (dyy*tailysca)**2
        #         img[i,j] = tailamp * r2 / (tailcore**2 + r2)**(1+tailinde/2.0)

        #- Make tail image (faster, less readable version)
        #- r2 = normalized distance from center of each pixel to PSF center
        r2 = np.tile((dx*tailxsca)**2, ny).reshape(ny, nx) + \
             np.repeat((dy*tailysca)**2, nx).reshape(ny, nx)
        tails = tailamp * r2 / (tailcore**2 + r2)**(1 + tailinde / 2.0)

        #- Create 1D GaussHermite functions in x and y
        xfunc1 = [pgh(xccd, i, x, sigma=sigx1) for i in range(degx1 + 1)]
        yfunc1 = [pgh(yccd, i, y, sigma=sigy1) for i in range(degy1 + 1)]

        #- Create core PSF image
        core1 = np.zeros((ny, nx))
        spot1 = np.empty_like(core1)

        if self.legval_dict is None:
            #non-cached branch

            for i in range(degx1 + 1):
                for j in range(degy1 + 1):
                    #note that we can't use self.core_keys here because it is
                    #only constructed in the cached branch. this is okay for
                    #now because line_profiler shows less than 1 percent of
                    #runtime is spent here
                    c1 = self.coeff['GH-{}-{}'.format(i, j)].eval(
                        ispec, wavelength)
                    outer(yfunc1[j], xfunc1[i], out=spot1)
                    core1 += c1 * spot1

        else:
            #cached branch

            #but first some prep
            npfx = np.array(xfunc1)
            npfy = np.array(yfunc1)

            #store values of c1
            c1_array = np.zeros((ny, nx))

            #get legval_value
            for i in range(degx1 + 1):
                for j in range(degy1 + 1):
                    #see if we can squeeze out some extra speed by looking up the values
                    c1_array[i, j] = self.legval_dict[self.core_keys[i][j]][
                        ispec_cache, iwave_cache]

            #call our numba-ized function that does some of the expensive
            #matrix multiplication and bookkeeping
            core1 = generate_core(degx1, degy1, npfx, npfy, spot1, core1,
                                  c1_array)

        #- Zero out elements in the core beyond 3 sigma
        #- Only for GaussHermite2
        # ghnsig = self.coeff['GHNSIG'].eval(ispec, wavelength)
        # r2 = np.tile((dx/sigx1)**2, ny).reshape(ny, nx) + \
        #      np.repeat((dy/sigy1)**2, nx).reshape(ny, nx)

        # core1 *= (r2<ghnsig**2)

        #this code will not work, needs to be modified for new pgh!
        #- Add second wider core Gauss-Hermite term
        # xfunc2 = [self._pgh(xccd, i, x, sigma=sigx2) for i in range(degx2+1)]
        # yfunc2 = [self._pgh(yccd, i, y, sigma=sigy2) for i in range(degy2+1)]
        # core2 = np.zeros((ny, nx))
        # for i in range(degx2+1):
        #     for j in range(degy2+1):
        #         spot2 = outer(yfunc2[j], xfunc2[i])
        #         c2 = self.coeff['GH2-{}-{}'.format(i,j)].eval(ispec, wavelength)
        #         core2 += c2 * spot2

        #- Clip negative values and normalize to 1.0
        img = core1 + tails
        ### img = core1 + core2 + tails

        img = img.clip(0.0)
        img /= np.sum(img)

        xslice = slice(xccd[0], xccd[-1] + 1)
        yslice = slice(yccd[0], yccd[-1] + 1)
        return xslice, yslice, img
        # return xslice, yslice, (core1, core2, tails)

    def _gh(self, x, m=0, xc=0.0, sigma=1.0):
        """
        return Gauss-Hermite function value, NOT integrated, for display of PSF.
        Arguments:
          x: coordinates baseline array
          m: order of Hermite polynomial multiplying Gaussian core
          xc: sub-pixel position of Gaussian centroid relative to x baseline
          sigma: sigma parameter of Gaussian core in units of pixels

        """

        u = (x - xc) / sigma

        if m > 0:
            return self._hermitenorm[m](u) * np.exp(-0.5 * u**2) / np.sqrt(
                2. * np.pi)
        else:
            return np.exp(-0.5 * u**2) / np.sqrt(2. * np.pi)

    def xsigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in cross-dispersion direction
        in CCD pixel units.

        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas
        """
        return self.coeff['GHSIGX'].eval(ispec, wavelength)

    def ysigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in dispersion direction
        in CCD pixel units.

        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas
        """
        return self.coeff['GHSIGY'].eval(ispec, wavelength)

    def _value(self, x, y, ispec, wavelength):
        """
        return PSF value (same shape as x and y), NOT integrated, for display of PSF.

        Arguments:
          x: x-coordinates baseline array
          y: y-coordinates baseline array (same shape as x)
          ispec: fiber
          wavelength: wavelength

        """

        # x, y = self.xy(ispec, wavelength)
        xc = self._x.eval(ispec, wavelength)
        yc = self._y.eval(ispec, wavelength)

        #- Extract GH degree and sigma coefficients for convenience
        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']
        sigx1 = self.coeff['GHSIGX'].eval(ispec, wavelength)
        sigy1 = self.coeff['GHSIGY'].eval(ispec, wavelength)

        #- Background tail image
        tailxsca = self.coeff['TAILXSCA'].eval(ispec, wavelength)
        tailysca = self.coeff['TAILYSCA'].eval(ispec, wavelength)
        tailamp = self.coeff['TAILAMP'].eval(ispec, wavelength)
        tailcore = self.coeff['TAILCORE'].eval(ispec, wavelength)
        tailinde = self.coeff['TAILINDE'].eval(ispec, wavelength)

        #- Make tail image (faster, less readable version)
        r2 = ((x - xc) * tailxsca)**2 + ((y - yc) * tailysca)**2
        tails = tailamp * r2 / (tailcore**2 + r2)**(1 + tailinde / 2.0)

        #- Create 1D GaussHermite functions in x and y
        xfunc1 = [self._gh(x, i, xc, sigma=sigx1) for i in range(degx1 + 1)]
        yfunc1 = [self._gh(y, i, yc, sigma=sigy1) for i in range(degy1 + 1)]

        #- Create core PSF image
        core1 = np.zeros(x.shape)
        for i in range(degx1 + 1):
            for j in range(degy1 + 1):
                c1 = self.coeff['GH-{}-{}'.format(i,
                                                  j)].eval(ispec, wavelength)
                core1 += c1 * yfunc1[j] * xfunc1[i]

        #- Clip negative values and normalize to 1.0
        img = core1 + tails
        ### img = core1 + core2 + tails

        img = img.clip(0.0)
        img /= np.sum(img)

        return img

    def cache_params(self, specrange, wavelengths):
        #store in a dict
        self.legval_dict = dict()
        #store keys in a list
        self.core_keys = list()
        for key in self.coeff.keys():
            self.legval_dict[key] = self.coeff[key].eval(
                specrange, wavelengths)
        #some extra steps to cache what we need for the core PSF image
        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']
        for i in range(degx1 + 1):
            self.core_keys.append(list())
            for j in range(degy1 + 1):
                self.core_keys[-1].append('GH-{}-{}'.format(i, j))
                self.legval_dict[self.core_keys[i][j]] = self.coeff[
                    self.core_keys[i][j]].eval(specrange, wavelengths)
Пример #8
0
class GaussHermitePSF(PSF):
    """
    Model PSF with two central Gauss-Hermite cores with different sigmas
    plus power law wings.
    """
    def __init__(self, filename):
        """
        Initialize GaussHermitePSF from input file
        """
        #- Check that this file is a current generation Gauss Hermite PSF
        fx = fits.open(filename, memmap=False)

        #- Read primary header
        phdr = fx[0].header
        if 'PSFTYPE' not in phdr:
            raise ValueError('Missing PSFTYPE keyword')
        if phdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(
                phdr['PSFTYPE']))
        if 'PSFVER' not in phdr:
            raise ValueError("PSFVER missing; this version not supported")
        PSFVER = float(phdr["PSFVER"])

        if PSFVER < 3:
            psf_hdu = 1
        else:
            psf_hdu = "PSF"

        self._polyparams = hdr = fx[psf_hdu].header
        if 'PSFTYPE' not in hdr:
            raise ValueError('Missing PSFTYPE keyword')

        if hdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(
                hdr['PSFTYPE']))

        if 'PSFVER' not in hdr:
            raise ValueError("PSFVER missing; this version not supported")

        if hdr['PSFVER'] < '1':
            raise ValueError(
                "Only GAUSS-HERMITE versions 1.0 and greater are supported")

        #- Calculate number of spectra from FIBERMIN and FIBERMAX (inclusive)
        self.nspec = hdr['FIBERMAX'] - hdr['FIBERMIN'] + 1

        #- Other necessary keywords
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']

        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load the parameters into self.coeff dictionary keyed by PARAM
        #- with values as TraceSets for evaluating the Legendre coefficients
        data = fx[psf_hdu].data
        self.coeff = dict()
        if PSFVER < 3:  # old format

            for p in data:
                domain = (p['WAVEMIN'], p['WAVEMAX'])
                for p in data:
                    name = p['PARAM'].strip()
                    self.coeff[name] = TraceSet(p['COEFF'], domain=domain)

            #- Pull out x and y as special tracesets
            self._x = self.coeff['X']
            self._y = self.coeff['Y']

        else:  # new format

            domain = (hdr['WAVEMIN'], hdr['WAVEMAX'])
            for p in data:
                name = p['PARAM'].strip()
                self.coeff[name] = TraceSet(p['COEFF'], domain=domain)

            self._x = TraceSet(fx["XTRACE"].data,
                               domain=(fx['XTRACE'].header["WAVEMIN"],
                                       fx['XTRACE'].header['WAVEMAX']))
            self._y = TraceSet(fx["YTRACE"].data,
                               domain=(fx['YTRACE'].header["WAVEMIN"],
                                       fx['YTRACE'].header['WAVEMAX']))

        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()
        self._wmin = np.min(self.wavelength(None, 0))
        self._wmin_all = np.max(self.wavelength(None, 0))
        self._wmax = np.max(self.wavelength(None, self.npix_y - 1))
        self._wmax_all = np.min(self.wavelength(None, self.npix_y - 1))

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None

        #- Cache hermitenorm polynomials so we don't have to create them
        #- every time xypix is called
        self._hermitenorm = list()
        maxdeg = max(hdr['GHDEGX'], hdr['GHDEGY'])
        for i in range(maxdeg + 1):
            self._hermitenorm.append(sp.hermitenorm(i))

        fx.close()

    def _pgh(self, x, m=0, xc=0.0, sigma=1.0):
        """
        Pixel-integrated (probabilist) Gauss-Hermite function.

        Arguments:
          x: pixel-center baseline array
          m: order of Hermite polynomial multiplying Gaussian core
          xc: sub-pixel position of Gaussian centroid relative to x baseline
          sigma: sigma parameter of Gaussian core in units of pixels

        Uses the relationship
        Integral{ H_k(x) exp(-0.5 x^2) dx} = -H_{k-1}(x) exp(-0.5 x^2) + const

        Written: Adam S. Bolton, U. of Utah, fall 2010
        Adapted for efficiency by S. Bailey while dropping generality
        """

        #- Evaluate H[m-1] at half-pixel offsets above and below x
        dx = x - xc - 0.5
        u = np.concatenate((dx, dx[-1:] + 0.5)) / sigma

        if m > 0:
            y = -self._hermitenorm[m - 1](u) * np.exp(-0.5 * u**2) / np.sqrt(
                2. * np.pi)
            return (y[1:] - y[0:-1])
        else:
            y = sp.erf(u / np.sqrt(2.))
            return 0.5 * (y[1:] - y[0:-1])

    def _xypix(self, ispec, wavelength):

        # x, y = self.xy(ispec, wavelength)
        x = self._x.eval(ispec, wavelength)
        y = self._y.eval(ispec, wavelength)

        #- CCD pixel ranges
        hsizex = self._polyparams['HSIZEX']
        hsizey = self._polyparams['HSIZEY']
        xccd = np.arange(int(x - hsizex + 0.5), int(x + hsizex + 1.5))
        yccd = np.arange(int(y - hsizey + 0.5), int(y + hsizey + 1.5))
        dx = xccd - x
        dy = yccd - y
        nx = len(dx)
        ny = len(dy)

        #- Extract GH degree and sigma coefficients for convenience
        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']
        sigx1 = self.coeff['GHSIGX'].eval(ispec, wavelength)
        sigy1 = self.coeff['GHSIGY'].eval(ispec, wavelength)

        #- Background tail image
        tailxsca = self.coeff['TAILXSCA'].eval(ispec, wavelength)
        tailysca = self.coeff['TAILYSCA'].eval(ispec, wavelength)
        tailamp = self.coeff['TAILAMP'].eval(ispec, wavelength)
        tailcore = self.coeff['TAILCORE'].eval(ispec, wavelength)
        tailinde = self.coeff['TAILINDE'].eval(ispec, wavelength)

        #- Make tail image (slow version)
        # img = np.zeros((len(yccd), len(xccd)))
        # for i, dyy in enumerate(dy):
        #     for j, dxx in enumerate(dx):
        #         r2 = (dxx*tailxsca)**2 + (dyy*tailysca)**2
        #         img[i,j] = tailamp * r2 / (tailcore**2 + r2)**(1+tailinde/2.0)

        #- Make tail image (faster, less readable version)
        #- r2 = normalized distance from center of each pixel to PSF center
        r2 = np.tile((dx*tailxsca)**2, ny).reshape(ny, nx) + \
             np.repeat((dy*tailysca)**2, nx).reshape(ny, nx)
        tails = tailamp * r2 / (tailcore**2 + r2)**(1 + tailinde / 2.0)

        #- Create 1D GaussHermite functions in x and y
        xfunc1 = [self._pgh(xccd, i, x, sigma=sigx1) for i in range(degx1 + 1)]
        yfunc1 = [self._pgh(yccd, i, y, sigma=sigy1) for i in range(degy1 + 1)]

        #- Create core PSF image
        core1 = np.zeros((ny, nx))
        for i in range(degx1 + 1):
            for j in range(degy1 + 1):
                c1 = self.coeff['GH-{}-{}'.format(i,
                                                  j)].eval(ispec, wavelength)
                spot1 = np.outer(yfunc1[j], xfunc1[i])
                core1 += c1 * spot1

        #- Zero out elements in the core beyond 3 sigma
        #- Only for GaussHermite2
        # ghnsig = self.coeff['GHNSIG'].eval(ispec, wavelength)
        # r2 = np.tile((dx/sigx1)**2, ny).reshape(ny, nx) + \
        #      np.repeat((dy/sigy1)**2, nx).reshape(ny, nx)

        # core1 *= (r2<ghnsig**2)

        #- Add second wider core Gauss-Hermite term
        # xfunc2 = [self._pgh(xccd, i, x, sigma=sigx2) for i in range(degx2+1)]
        # yfunc2 = [self._pgh(yccd, i, y, sigma=sigy2) for i in range(degy2+1)]
        # core2 = np.zeros((ny, nx))
        # for i in range(degx2+1):
        #     for j in range(degy2+1):
        #         spot2 = np.outer(yfunc2[j], xfunc2[i])
        #         c2 = self.coeff['GH2-{}-{}'.format(i,j)].eval(ispec, wavelength)
        #         core2 += c2 * spot2

        #- Clip negative values and normalize to 1.0
        img = core1 + tails
        ### img = core1 + core2 + tails

        img = img.clip(0.0)
        img /= np.sum(img)

        xslice = slice(xccd[0], xccd[-1] + 1)
        yslice = slice(yccd[0], yccd[-1] + 1)
        return xslice, yslice, img
        # return xslice, yslice, (core1, core2, tails)

    def _gh(self, x, m=0, xc=0.0, sigma=1.0):
        """
        return Gauss-Hermite function value, NOT integrated, for display of PSF.

        Arguments:
          x: coordinates baseline array
          m: order of Hermite polynomial multiplying Gaussian core
          xc: sub-pixel position of Gaussian centroid relative to x baseline
          sigma: sigma parameter of Gaussian core in units of pixels
        
        """

        u = (x - xc) / sigma

        if m > 0:
            return self._hermitenorm[m](u) * np.exp(-0.5 * u**2) / np.sqrt(
                2. * np.pi)
        else:
            return np.exp(-0.5 * u**2) / np.sqrt(2. * np.pi)

    def _value(self, x, y, ispec, wavelength):
        """
        return PSF value (same shape as x and y), NOT integrated, for display of PSF.

        Arguments:
          x: x-coordinates baseline array
          y: y-coordinates baseline array (same shape as x)
          ispec: fiber
          wavelength: wavelength
       
        """

        # x, y = self.xy(ispec, wavelength)
        xc = self._x.eval(ispec, wavelength)
        yc = self._y.eval(ispec, wavelength)

        #- Extract GH degree and sigma coefficients for convenience
        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']
        sigx1 = self.coeff['GHSIGX'].eval(ispec, wavelength)
        sigy1 = self.coeff['GHSIGY'].eval(ispec, wavelength)

        #- Background tail image
        tailxsca = self.coeff['TAILXSCA'].eval(ispec, wavelength)
        tailysca = self.coeff['TAILYSCA'].eval(ispec, wavelength)
        tailamp = self.coeff['TAILAMP'].eval(ispec, wavelength)
        tailcore = self.coeff['TAILCORE'].eval(ispec, wavelength)
        tailinde = self.coeff['TAILINDE'].eval(ispec, wavelength)

        #- Make tail image (faster, less readable version)
        r2 = ((x - xc) * tailxsca)**2 + ((y - yc) * tailysca)**2
        tails = tailamp * r2 / (tailcore**2 + r2)**(1 + tailinde / 2.0)

        #- Create 1D GaussHermite functions in x and y
        xfunc1 = [self._gh(x, i, xc, sigma=sigx1) for i in range(degx1 + 1)]
        yfunc1 = [self._gh(y, i, yc, sigma=sigy1) for i in range(degy1 + 1)]

        #- Create core PSF image
        core1 = np.zeros(x.shape)
        for i in range(degx1 + 1):
            for j in range(degy1 + 1):
                c1 = self.coeff['GH-{}-{}'.format(i,
                                                  j)].eval(ispec, wavelength)
                core1 += c1 * yfunc1[j] * xfunc1[i]

        #- Clip negative values and normalize to 1.0
        img = core1 + tails
        ### img = core1 + core2 + tails

        img = img.clip(0.0)
        img /= np.sum(img)

        return img
Пример #9
0
    def __init__(self, filename):
        """
        Initialize GaussHermitePSF from input file
        """        
        #- Check that this file is a current generation Gauss Hermite PSF
        fx = fits.open(filename, memmap=False)

        #- Read primary header
        phdr = fx[0].header
        if 'PSFTYPE' not in phdr:
            raise ValueError('Missing PSFTYPE keyword')
        if phdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(phdr['PSFTYPE']))
        if 'PSFVER' not in phdr:
            raise ValueError("PSFVER missing; this version not supported")
        PSFVER = float(phdr["PSFVER"])
        
        if PSFVER<3 :
            psf_hdu = 1
        else :
            psf_hdu = "PSF"
        
        self._polyparams = hdr = dict(fx[psf_hdu].header)
        if 'PSFTYPE' not in hdr:
            raise ValueError('Missing PSFTYPE keyword')
            
        if hdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(hdr['PSFTYPE']))
            
        if 'PSFVER' not in hdr:
            raise ValueError("PSFVER missing; this version not supported")
            
        if hdr['PSFVER'] < '1':
            raise ValueError("Only GAUSS-HERMITE versions 1.0 and greater are supported")
            
        #- Calculate number of spectra from FIBERMIN and FIBERMAX (inclusive)
        self.nspec = hdr['FIBERMAX'] - hdr['FIBERMIN'] + 1
        
        #- Other necessary keywords
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']

        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load the parameters into self.coeff dictionary keyed by PARAM
        #- with values as TraceSets for evaluating the Legendre coefficients
        data = fx[psf_hdu].data
        self.coeff = dict()
        if PSFVER<3 : # old format
            
            for p in data:
                domain = (p['WAVEMIN'], p['WAVEMAX'])
                for p in data:
                    name = p['PARAM'].strip()
                    self.coeff[name] = TraceSet(p['COEFF'], domain=domain)
    
            #- Pull out x and y as special tracesets
            self._x = self.coeff['X']
            self._y = self.coeff['Y']

        else : # new format
            
            domain = (hdr['WAVEMIN'], hdr['WAVEMAX'])
            for p in data:
                name = p['PARAM'].strip()
                self.coeff[name] = TraceSet(p['COEFF'], domain=domain)
            
            self._x = TraceSet(fx["XTRACE"].data, domain=(fx['XTRACE'].header["WAVEMIN"], fx['XTRACE'].header['WAVEMAX']))
            self._y = TraceSet(fx["YTRACE"].data, domain=(fx['YTRACE'].header["WAVEMIN"], fx['YTRACE'].header['WAVEMAX']))
            
        
        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()

        #- Cache min/max wavelength per fiber at pixel edges
        self._wmin_spec = self.wavelength(None, -0.5)
        self._wmax_spec = self.wavelength(None, self.npix_y-0.5)
        self._wmin = np.min(self._wmin_spec)
        self._wmin_all = np.max(self._wmin_spec)
        self._wmax = np.max(self._wmax_spec)
        self._wmax_all = np.min(self._wmax_spec)

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None

        #create dict to hold legval cached data
        self.legval_dict = None

        #- Cache hermitenorm polynomials so we don't have to create them
        #- every time xypix is called
        self._hermitenorm = list()
        maxdeg = max(hdr['GHDEGX'], hdr['GHDEGY'])
        for i in range(maxdeg+1):
            self._hermitenorm.append( sp.hermitenorm(i) )

        fx.close()
Пример #10
0
class GaussHermitePSF(PSF):
    """
    Model PSF with two central Gauss-Hermite cores with different sigmas
    plus power law wings.
    """
    def __init__(self, filename):
        """
        Initialize GaussHermitePSF from input file
        """        
        #- Check that this file is a current generation Gauss Hermite PSF
        fx = fits.open(filename, memmap=False)

        #- Read primary header
        phdr = fx[0].header
        if 'PSFTYPE' not in phdr:
            raise ValueError('Missing PSFTYPE keyword')
        if phdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(phdr['PSFTYPE']))
        if 'PSFVER' not in phdr:
            raise ValueError("PSFVER missing; this version not supported")
        PSFVER = float(phdr["PSFVER"])
        
        if PSFVER<3 :
            psf_hdu = 1
        else :
            psf_hdu = "PSF"
        
        self._polyparams = hdr = dict(fx[psf_hdu].header)
        if 'PSFTYPE' not in hdr:
            raise ValueError('Missing PSFTYPE keyword')
            
        if hdr['PSFTYPE'] != 'GAUSS-HERMITE':
            raise ValueError('PSFTYPE {} is not GAUSS-HERMITE'.format(hdr['PSFTYPE']))
            
        if 'PSFVER' not in hdr:
            raise ValueError("PSFVER missing; this version not supported")
            
        if hdr['PSFVER'] < '1':
            raise ValueError("Only GAUSS-HERMITE versions 1.0 and greater are supported")
            
        #- Calculate number of spectra from FIBERMIN and FIBERMAX (inclusive)
        self.nspec = hdr['FIBERMAX'] - hdr['FIBERMIN'] + 1
        
        #- Other necessary keywords
        self.npix_x = hdr['NPIX_X']
        self.npix_y = hdr['NPIX_Y']

        #- PSF model error
        if 'PSFERR' in hdr:
            self.psferr = hdr['PSFERR']
        else:
            self.psferr = 0.01

        #- Load the parameters into self.coeff dictionary keyed by PARAM
        #- with values as TraceSets for evaluating the Legendre coefficients
        data = fx[psf_hdu].data
        self.coeff = dict()
        if PSFVER<3 : # old format
            
            for p in data:
                domain = (p['WAVEMIN'], p['WAVEMAX'])
                for p in data:
                    name = p['PARAM'].strip()
                    self.coeff[name] = TraceSet(p['COEFF'], domain=domain)
    
            #- Pull out x and y as special tracesets
            self._x = self.coeff['X']
            self._y = self.coeff['Y']

        else : # new format
            
            domain = (hdr['WAVEMIN'], hdr['WAVEMAX'])
            for p in data:
                name = p['PARAM'].strip()
                self.coeff[name] = TraceSet(p['COEFF'], domain=domain)
            
            self._x = TraceSet(fx["XTRACE"].data, domain=(fx['XTRACE'].header["WAVEMIN"], fx['XTRACE'].header['WAVEMAX']))
            self._y = TraceSet(fx["YTRACE"].data, domain=(fx['YTRACE'].header["WAVEMIN"], fx['YTRACE'].header['WAVEMAX']))
            
        
        #- Create inverse y -> wavelength mapping
        self._w = self._y.invert()

        #- Cache min/max wavelength per fiber at pixel edges
        self._wmin_spec = self.wavelength(None, -0.5)
        self._wmax_spec = self.wavelength(None, self.npix_y-0.5)
        self._wmin = np.min(self._wmin_spec)
        self._wmin_all = np.max(self._wmin_spec)
        self._wmax = np.max(self._wmax_spec)
        self._wmax_all = np.min(self._wmax_spec)

        #- Filled only if needed
        self._xsigma = None
        self._ysigma = None

        #create dict to hold legval cached data
        self.legval_dict = None

        #- Cache hermitenorm polynomials so we don't have to create them
        #- every time xypix is called
        self._hermitenorm = list()
        maxdeg = max(hdr['GHDEGX'], hdr['GHDEGY'])
        for i in range(maxdeg+1):
            self._hermitenorm.append( sp.hermitenorm(i) )

        fx.close()

    def _xypix(self, ispec, wavelength, ispec_cache=None, iwave_cache=None):
        """
        Two branches of this function which does legendre series fitting
        First branch = no caching, will recompute legval every time eval is used (slow)
        Second branch = yes caching, will look up precomputed values of legval (faster)

        Arguments:
            ispec: the index of each spectrum
            wavelength: the wavelength at which to evaluate the legendre series
            
        Optional arguments:
            ispec_cache: the index of each spectrum which starts again at 0 for each patch
            iwave_cache: the index of each wavelength which starts again at 0 for each patch
        """

        #trying to avoid duplicating code between branches, will split into
        #cached branch and non-cached branch depending on self.legval_dict

        #we need this for the original indexing so skip looking up cached values here
        x = self._x.eval(ispec, wavelength)
        y = self._y.eval(ispec, wavelength)

        #- CCD pixel ranges
        hsizex = self._polyparams['HSIZEX']
        hsizey = self._polyparams['HSIZEY']
        xccd = np.arange(int(x-hsizex+0.5), int(x+hsizex+1.5))
        yccd = np.arange(int(y-hsizey+0.5), int(y+hsizey+1.5))

        dx = xccd - x
        dy = yccd - y
        nx = len(dx)
        ny = len(dy)

        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']

        if self.legval_dict is None:
            #non-cached branch
            #print("self.legval_dict is None, hitting non-cached branch")

            #- Extract GH degree and sigma coefficients for convenience
            sigx1 = self.coeff['GHSIGX'].eval(ispec, wavelength)
            sigy1 = self.coeff['GHSIGY'].eval(ispec, wavelength)
        
            #- Background tail image
            tailxsca = self.coeff['TAILXSCA'].eval(ispec, wavelength)
            tailysca = self.coeff['TAILYSCA'].eval(ispec, wavelength)
            tailamp = self.coeff['TAILAMP'].eval(ispec, wavelength)
            tailcore = self.coeff['TAILCORE'].eval(ispec, wavelength)
            tailinde = self.coeff['TAILINDE'].eval(ispec, wavelength)
 
        else:
            #cached branch
            #print("self.legval_dict is not None, hitting cached branch")

            #- Extract GH degree and sigma coefficients for convenience
            sigx1 = self.legval_dict['GHSIGX'][ispec_cache, iwave_cache]
            sigy1 = self.legval_dict['GHSIGY'][ispec_cache, iwave_cache]

            #- Background tail image
            tailxsca = self.legval_dict['TAILXSCA'][ispec_cache, iwave_cache]
            tailysca = self.legval_dict['TAILYSCA'][ispec_cache, iwave_cache]
            tailamp = self.legval_dict['TAILAMP'][ispec_cache, iwave_cache]
            tailcore = self.legval_dict['TAILCORE'][ispec_cache, iwave_cache]
            tailinde = self.legval_dict['TAILINDE'][ispec_cache, iwave_cache]

        
        #- Make tail image (slow version)
        # img = np.zeros((len(yccd), len(xccd)))
        # for i, dyy in enumerate(dy):
        #     for j, dxx in enumerate(dx):
        #         r2 = (dxx*tailxsca)**2 + (dyy*tailysca)**2
        #         img[i,j] = tailamp * r2 / (tailcore**2 + r2)**(1+tailinde/2.0)

        #- Make tail image (faster, less readable version)
        #- r2 = normalized distance from center of each pixel to PSF center
        r2 = np.tile((dx*tailxsca)**2, ny).reshape(ny, nx) + \
             np.repeat((dy*tailysca)**2, nx).reshape(ny, nx)
        tails = tailamp*r2 / (tailcore**2 + r2)**(1+tailinde/2.0)
        
        #- Create 1D GaussHermite functions in x and y
        xfunc1 = [pgh(xccd, i, x, sigma=sigx1) for i in range(degx1+1)]
        yfunc1 = [pgh(yccd, i, y, sigma=sigy1) for i in range(degy1+1)]        
       
        #- Create core PSF image
        core1 = np.zeros((ny, nx))
        spot1 = np.empty_like(core1)

        if self.legval_dict is None:
            #non-cached branch

            for i in range(degx1+1):
                for j in range(degy1+1):
                    #note that we can't use self.core_keys here because it is 
                    #only constructed in the cached branch. this is okay for
                    #now because line_profiler shows less than 1 percent of
                    #runtime is spent here
                    c1 = self.coeff['GH-{}-{}'.format(i,j)].eval(ispec, wavelength)
                    outer(yfunc1[j], xfunc1[i], out=spot1)
                    core1 += c1 * spot1

        else:
            #cached branch

            #but first some prep
            npfx = np.array(xfunc1)
            npfy = np.array(yfunc1)

            #store values of c1
            c1_array = np.zeros((ny, nx))

            #get legval_value
            for i in range(degx1+1):
                for j in range(degy1+1):
                    #see if we can squeeze out some extra speed by looking up the values
                    c1_array[i,j] = self.legval_dict[self.core_keys[i][j]][ispec_cache, iwave_cache]

            #call our numba-ized function that does some of the expensive
            #matrix multiplication and bookkeeping
            core1 = generate_core(degx1, degy1, npfx, npfy, spot1, core1, c1_array)

        #- Zero out elements in the core beyond 3 sigma
        #- Only for GaussHermite2
        # ghnsig = self.coeff['GHNSIG'].eval(ispec, wavelength)
        # r2 = np.tile((dx/sigx1)**2, ny).reshape(ny, nx) + \
        #      np.repeat((dy/sigy1)**2, nx).reshape(ny, nx)
        
        # core1 *= (r2<ghnsig**2)
        
        #this code will not work, needs to be modified for new pgh!
        #- Add second wider core Gauss-Hermite term        
        # xfunc2 = [self._pgh(xccd, i, x, sigma=sigx2) for i in range(degx2+1)]
        # yfunc2 = [self._pgh(yccd, i, y, sigma=sigy2) for i in range(degy2+1)]
        # core2 = np.zeros((ny, nx))
        # for i in range(degx2+1):
        #     for j in range(degy2+1):
        #         spot2 = outer(yfunc2[j], xfunc2[i])
        #         c2 = self.coeff['GH2-{}-{}'.format(i,j)].eval(ispec, wavelength)
        #         core2 += c2 * spot2

        #- Clip negative values and normalize to 1.0
        img = core1 + tails
        ### img = core1 + core2 + tails

        img = img.clip(0.0)
        img /= np.sum(img)

        xslice = slice(xccd[0], xccd[-1]+1)
        yslice = slice(yccd[0], yccd[-1]+1)
        return xslice, yslice, img
        # return xslice, yslice, (core1, core2, tails)
        
    def _gh(self, x, m=0, xc=0.0, sigma=1.0):
        """
        return Gauss-Hermite function value, NOT integrated, for display of PSF.
        Arguments:
          x: coordinates baseline array
          m: order of Hermite polynomial multiplying Gaussian core
          xc: sub-pixel position of Gaussian centroid relative to x baseline
          sigma: sigma parameter of Gaussian core in units of pixels
        
        """

        
        u = (x-xc) / sigma
        
        if m > 0:
            return self._hermitenorm[m](u) * np.exp(-0.5 * u**2) / np.sqrt(2. * np.pi)
        else:                        
            return np.exp(-0.5 * u**2) / np.sqrt(2. * np.pi)       


    def xsigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in cross-dispersion direction
        in CCD pixel units.
        
        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas
        """
        return self.coeff['GHSIGX'].eval(ispec, wavelength)
    
    def ysigma(self, ispec, wavelength):
        """
        Return Gaussian sigma of PSF spot in dispersion direction
        in CCD pixel units.
        
        ispec : spectrum index
        wavelength : scalar or vector wavelength(s) to evaluate spot sigmas
        """
        return self.coeff['GHSIGY'].eval(ispec, wavelength)
    

    def _value(self,x,y,ispec, wavelength):
        
        """
        return PSF value (same shape as x and y), NOT integrated, for display of PSF.

        Arguments:
          x: x-coordinates baseline array
          y: y-coordinates baseline array (same shape as x)
          ispec: fiber
          wavelength: wavelength
       
        """

        # x, y = self.xy(ispec, wavelength)
        xc = self._x.eval(ispec, wavelength)
        yc = self._y.eval(ispec, wavelength)
                
        #- Extract GH degree and sigma coefficients for convenience
        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']
        sigx1 = self.coeff['GHSIGX'].eval(ispec, wavelength)
        sigy1 = self.coeff['GHSIGY'].eval(ispec, wavelength)
        
        #- Background tail image
        tailxsca = self.coeff['TAILXSCA'].eval(ispec, wavelength)
        tailysca = self.coeff['TAILYSCA'].eval(ispec, wavelength)
        tailamp = self.coeff['TAILAMP'].eval(ispec, wavelength)
        tailcore = self.coeff['TAILCORE'].eval(ispec, wavelength)
        tailinde = self.coeff['TAILINDE'].eval(ispec, wavelength)
        
        
        #- Make tail image (faster, less readable version)
        r2 = ((x-xc)*tailxsca)**2+((y-yc)*tailysca)**2
        tails = tailamp*r2 / (tailcore**2 + r2)**(1+tailinde/2.0)
        
        #- Create 1D GaussHermite functions in x and y
        xfunc1 = [self._gh(x, i, xc, sigma=sigx1) for i in range(degx1+1)]
        yfunc1 = [self._gh(y, i, yc, sigma=sigy1) for i in range(degy1+1)]        
        
        
        #- Create core PSF image
        core1 = np.zeros(x.shape)
        for i in range(degx1+1):
            for j in range(degy1+1):
                c1 = self.coeff['GH-{}-{}'.format(i,j)].eval(ispec, wavelength)
                core1 += c1 * yfunc1[j]*xfunc1[i]
        
        #- Clip negative values and normalize to 1.0
        img = core1 + tails
        ### img = core1 + core2 + tails

        img = img.clip(0.0)
        img /= np.sum(img)

        return img

    def cache_params(self, specrange, wavelengths):
        #store in a dict
        self.legval_dict = dict()
        #store keys in a list
        self.core_keys = list()
        for key in self.coeff.keys():
            self.legval_dict[key] = self.coeff[key].eval(specrange, wavelengths)
        #some extra steps to cache what we need for the core PSF image
        degx1 = self._polyparams['GHDEGX']
        degy1 = self._polyparams['GHDEGY']
        for i in range(degx1+1):
            self.core_keys.append(list())
            for j in range(degy1+1):
                self.core_keys[-1].append('GH-{}-{}'.format(i,j))
                self.legval_dict[self.core_keys[i][j]]=self.coeff[self.core_keys[i][j]].eval(specrange, wavelengths)