Ejemplo n.º 1
0
    def cutOutOrder(self, flatOrder):

        # determine cutout padding
        flatOrder.cutoutPadding = config.get_cutout_padding(
            self.filterName, self.slit)

        # add extra padding for orders with large tilt
        tilt = abs(flatOrder.avgEdgeTrace[0] - flatOrder.avgEdgeTrace[-1])
        if tilt > config.params['large_tilt_threshold']:
            self.logger.info('large order tilt detected, tilt = ' +
                             str(round(tilt, 1)) + ' threshold = ' +
                             str(config.params['large_tilt_threshold']) +
                             ' extra padding = ' +
                             str(config.params['large_tilt_extra_padding']))
            flatOrder.cutoutPadding += config.params[
                'large_tilt_extra_padding']
        self.logger.debug('cutout padding = ' +
                          str(round(flatOrder.cutoutPadding, 0)))

        # determine highest point of top trace (ignore edge)
        if flatOrder.topEdgeTrace is None:
            flatOrder.topEdgeTrace = flatOrder.botEdgeTrace + \
                (flatOrder.topCalc - flatOrder.botCalc) - 5

        flatOrder.highestPoint = np.amax(
            flatOrder.topEdgeTrace[0:-config.params['overscan_width']])

        if flatOrder.botEdgeTrace is None:
            flatOrder.botEdgeTrace = flatOrder.topEdgeTrace - \
                    (flatOrder.topCalc - flatOrder.botCalc) + 5

        flatOrder.lowestPoint = np.amin(
            flatOrder.botEdgeTrace[0:-config.params['overscan_width']])

        flatOrder.cutout = np.array(
            image_lib.cut_out(self.flatImg, flatOrder.highestPoint,
                              flatOrder.lowestPoint, flatOrder.cutoutPadding))

        if float(flatOrder.lowestPoint) > float(flatOrder.cutoutPadding):
            flatOrder.onOrderMask, flatOrder.offOrderMask = get_masks(
                flatOrder.cutout.shape, flatOrder.topEdgeTrace -
                flatOrder.lowestPoint + flatOrder.cutoutPadding,
                flatOrder.botEdgeTrace - flatOrder.lowestPoint +
                flatOrder.cutoutPadding)
        else:
            flatOrder.onOrderMask, flatOrder.offOrderMask = get_masks(
                flatOrder.cutout.shape, flatOrder.topEdgeTrace,
                flatOrder.botEdgeTrace)

        flatOrder.cutout = np.ma.masked_array(flatOrder.cutout,
                                              mask=flatOrder.offOrderMask)

        return
Ejemplo n.º 2
0
def __flatten(order, eta=None, arc=None):
    """Flat field object image[s] but keep originals for noise calculation.
    """

    for frame in order.frames:

        order.objImg[frame] = np.array(order.objCutout[frame])
        order.ffObjImg[frame] = np.array(order.objCutout[frame] /
                                         order.flatOrder.normFlatImg)

        #Also cut out the flat fielded object
        order.ffObjCutout[frame] = np.array(
            image_lib.cut_out(order.ffObjImg[frame],
                              order.flatOrder.highestPoint,
                              order.flatOrder.lowestPoint,
                              order.flatOrder.cutoutPadding))
        # Add then mask it
        order.ffObjCutout[frame] = np.ma.masked_array(
            order.objCutout[frame], mask=order.flatOrder.offOrderMask)

        if frame != 'AB':
            if np.amin(order.ffObjImg[frame]) < 0:
                order.ffObjImg[frame] -= np.amin(order.ffObjImg[frame])

        if eta is not None:
            if frame == 'B':
                order.etaImgB = np.array(order.etaCutout)
                order.ffEtaImgB = np.array(order.etaCutout /
                                           order.flatOrder.normFlatImg)
            else:
                order.etaImg = np.array(order.etaCutout)
                order.ffEtaImg = np.array(order.etaCutout /
                                          order.flatOrder.normFlatImg)

        if arc is not None:
            if frame == 'B':
                order.arcImgB = np.array(order.arcCutout)
                order.ffArcImgB = np.array(order.arcCutout /
                                           order.flatOrder.normFlatImg)
            else:
                order.arcImg = np.array(order.arcCutout)
                order.ffArcImg = np.array(order.arcCutout /
                                          order.flatOrder.normFlatImg)

    order.flattened = True
    logger.info('order has been flat fielded')
    return
Ejemplo n.º 3
0
 def cutOutOrder(self, flatOrder):
     
     # determine cutout padding
     flatOrder.cutoutPadding = config.get_cutout_padding(self.filterName, self.slit)
     
     # add extra padding for orders with large tilt
     tilt = abs(flatOrder.avgEdgeTrace[0] - flatOrder.avgEdgeTrace[-1])
     if  tilt > config.params['large_tilt_threshold']:
         self.logger.info('large order tilt detected, tilt = ' + str(round(tilt, 1)) + 
             ' threshold = ' + str(config.params['large_tilt_threshold']) + 
             ' extra padding = ' + str(config.params['large_tilt_extra_padding']))
         flatOrder.cutoutPadding += config.params['large_tilt_extra_padding']
     self.logger.debug('cutout padding = ' + str(round(flatOrder.cutoutPadding, 0)))
     
     # determine highest point of top trace (ignore edge)
     if flatOrder.topEdgeTrace is None:
         flatOrder.topEdgeTrace = flatOrder.botEdgeTrace + \
             (flatOrder.topCalc - flatOrder.botCalc) - 5
         
     flatOrder.highestPoint = np.amax(flatOrder.topEdgeTrace[0:-config.params['overscan_width']])
         
     if flatOrder.botEdgeTrace is None:
         flatOrder.botEdgeTrace = flatOrder.topEdgeTrace - \
                 (flatOrder.topCalc - flatOrder.botCalc) + 5
         
     flatOrder.lowestPoint = np.amin(flatOrder.botEdgeTrace[0:-config.params['overscan_width']])
          
     flatOrder.cutout = np.array(image_lib.cut_out(
             self.flatImg, flatOrder.highestPoint, flatOrder.lowestPoint, 
             flatOrder.cutoutPadding))
             
     if float(flatOrder.lowestPoint) > float(flatOrder.cutoutPadding):
         flatOrder.onOrderMask, flatOrder.offOrderMask = get_masks(
                 flatOrder.cutout.shape, 
                 flatOrder.topEdgeTrace - flatOrder.lowestPoint + flatOrder.cutoutPadding, 
                 flatOrder.botEdgeTrace - flatOrder.lowestPoint + flatOrder.cutoutPadding)
     else:
         flatOrder.onOrderMask, flatOrder.offOrderMask = get_masks(
                 flatOrder.cutout.shape, flatOrder.topEdgeTrace, flatOrder.botEdgeTrace)
         
     flatOrder.cutout = np.ma.masked_array(flatOrder.cutout, mask=flatOrder.offOrderMask)
 
     return
def reduce_orders(reduced):
    """Reduces each order in the frame.

    Starting order is determined from a lookup table indexed by filter name.

    The grating equation is evaluated for y-axis location of the short wavelength end
    of the order on the detector.

    If the order is on the detector then extract_order() is called to cut out from the full
    frame a rectangular array of pixels containing the entire order plus padding.

    Then, reduce_order() is called to reduce the order.
    reduce_order() returns an order object which is and instance of the Order class
    and contains all of the reduced data for this order.  The order object is then
    appended to the list of order objects in the ReducedDataSet object representing
    the current frame.

    After the first order that should be on the detector is found, processing continues
    through each order in descending order number, working toward higher pixel row numbers
    on the detector, until the first off-detector order is found.
    """

    for flatOrder in reduced.Flat.flatOrders:
        if flatOrder.valid is not True:
            continue

        logger.info('***** order ' + str(flatOrder.orderNum) + ' *****')

        order = Order.Order(reduced.frames, reduced.baseNames, flatOrder)

        order.isPair = reduced.isPair

        for frame in order.frames:
            order.objCutout[frame] = np.array(image_lib.cut_out(reduced.objImg[frame],
                                                                flatOrder.highestPoint, flatOrder.lowestPoint, flatOrder.cutoutPadding))

        order.integrationTime = reduced.getIntegrationTime()  # used in noise calc

        try:

            # reduce order, i.e. rectify, extract spectra, identify sky lines
            reduce_order.reduce_order(order)

            # add reduced order to list of reduced orders in Reduced object
            reduced.orders.append(order)

        except DrpException.DrpException as e:
            logger.warning('failed to reduce order {}: {}'.format(
                str(flatOrder.orderNum), e.message))

        # end if order is on the detector
    # end for each order

    loggers = ['obj']
    if config.params['cmnd_line_mode'] is False:
        loggers.append('main')
#     for l in loggers:
#         logging.getLogger(l).log(INFO, 'n orders on the detector = {}'.format(n_orders_on_detector))
#         logging.getLogger(l).log(INFO, 'n orders reduced = {}'.format(len(reduced.orders)))

    if len(reduced.orders) == 0:
        return

    for l in loggers:
        reduced.snrMean = sum(reduced.orders[i].snr['A'] for i in range(len(reduced.orders))) / \
            len(reduced.orders)
        logging.getLogger(l).log(INFO, 'mean signal-to-noise ratio = {:.1f}'.format(
            reduced.snrMean))

    snr = []
    for i in range(len(reduced.orders)):
        snr.append(reduced.orders[i].snr['A'])

    for l in loggers:
        reduced.snrMin = np.amin(snr)
        logging.getLogger(l).log(INFO, 'minimum signal-to-noise ratio = {:.1f}'.format(
            reduced.snrMin))

        try:
            reduced.wMean = sum(abs(reduced.orders[i].gaussianParams['A'][2])
                                for i in range(len(reduced.orders))) / len(reduced.orders)
            logging.getLogger(l).log(INFO, 'mean spatial peak width = {:.1f} pixels'.format(
                reduced.wMean))
        except BaseException:
            logging.getLogger(l).log(
                logging.WARNING,
                'mean spatial peak width = unknown')

        w = []
        for i in range(len(reduced.orders)):
            if reduced.orders[i].gaussianParams['A'] is not None:
                w.append(reduced.orders[i].gaussianParams['A'][2])
        try:
            reduced.wMax = np.amax(w)
            logging.getLogger(l).log(INFO, 'maximum spatial peak width = {:.1f} pixels'.format(
                reduced.wMax))
        except BaseException:
            logging.getLogger(l).error(
                'maximum spatial peak width cannot be determined')
            logging.getLogger(l).log(
                INFO, 'maximum spatial peak width = unknown')

    return
Ejemplo n.º 5
0
def reduce_orders(reduced):
    """
    Successively reduces each order in the frame.  
    
    Starting order is determined from a lookup table indexed by filter name.
    
    The grating equation is evaluated for y-axis location of the short wavelength end
    of the order on the detector.
    
    If the order is on the detector then extract_order() is called to cut out from the full
    frame a rectangular array of pixels containing the entire order plus padding.  
    
    Then, reduce_order() is called to reduce the order.
    reduce_order() returns an order object which is and instance of the Order class 
    and contains all of the reduced data for this order.  The order object is then
    appended to the list of order objects in the ReducedDataSet object representing 
    the current frame.
    
    After the first order that should be on the detector is found, processing continues
    through each order in descending order number, working toward higher pixel row numbers
    on the detector, until the first off-detector order is found.
    """
    
    for flatOrder in reduced.Flat.flatOrders:
        if flatOrder.valid is not True:
            continue        
        
        logger.info('***** order ' + str(flatOrder.orderNum) + ' *****')
            
        order = Order.Order(reduced.baseName, flatOrder.orderNum)
            
        order.objCutout = np.array(image_lib.cut_out(reduced.obj, 
                flatOrder.highestPoint, flatOrder.lowestPoint, flatOrder.cutoutPadding))
        
        order.integrationTime = reduced.getIntegrationTime() # used in noise calc
        order.gratingEqWaveScale = flatOrder.gratingEqWaveScale
        #order.wavelengthScaleMeas = flatOrder.waveScaleCalc
        order.topTrace = flatOrder.topEdgeTrace
        order.botTrace = flatOrder.botEdgeTrace
        order.avgTrace = flatOrder.avgEdgeTrace
        order.smoothedTrace = flatOrder.smoothedSpatialTrace
        order.traceMask = flatOrder.spatialTraceMask
        order.flatCutout = flatOrder.cutout
        order.highestPoint = flatOrder.highestPoint
        order.lowestPoint = flatOrder.lowestPoint
        order.padding = flatOrder.cutoutPadding
        order.botMeas = flatOrder.botMeas
            
        try:
            
            # reduce order, i.e. rectify, extract spectra, identify sky lines
            reduce_order.reduce_order(order, flatOrder)
    
            # add reduced order to list of reduced orders in Reduced object
            reduced.orders.append(order)                      

        except DrpException.DrpException as e:
            logger.warning('failed to reduce order {}: {}'.format(
                     str(flatOrder.orderNum), e.message))
 
                        
        # end if order is on the detector
    # end for each order

    loggers = ['obj']
    if config.params['cmnd_line_mode'] is False:
        loggers.append('main')
#     for l in loggers:
#         logging.getLogger(l).log(INFO, 'n orders on the detector = {}'.format(n_orders_on_detector))
#         logging.getLogger(l).log(INFO, 'n orders reduced = {}'.format(len(reduced.orders)))
        
    if len(reduced.orders) == 0:
        return
    
    for l in loggers:
        reduced.snrMean = sum(reduced.orders[i].snr for i in range(len(reduced.orders))) / \
                len(reduced.orders)
        logging.getLogger(l).log(INFO, 'mean signal-to-noise ratio = {:.1f}'.format(
                reduced.snrMean))
    
    snr = []
    for i in range(len(reduced.orders)):
        snr.append(reduced.orders[i].snr)
    
    for l in loggers:
        reduced.snrMin = np.amin(snr)
        logging.getLogger(l).log(INFO, 'minimum signal-to-noise ratio = {:.1f}'.format(
                reduced.snrMin))
    
        try:
            reduced.wMean = sum(abs(reduced.orders[i].gaussianParams[2]) \
                    for i in range(len(reduced.orders))) /  len(reduced.orders)
            logging.getLogger(l).log(INFO, 'mean spatial peak width = {:.1f} pixels'.format(
                    reduced.wMean))
        except:
            logging.getLogger(l).log(logging.WARNING, 'mean spatial peak width = unknown') 
    
        w = []
        for i in range(len(reduced.orders)):
            if reduced.orders[i].gaussianParams is not None:
                w.append(reduced.orders[i].gaussianParams[2])
        try:
            reduced.wMax = np.amax(w)
            logging.getLogger(l).log(INFO, 'maximum spatial peak width = {:.1f} pixels'.format(
                    reduced.wMax))
        except:
            logging.getLogger(l).error('maximum spatial peak width cannot be determined')
            logging.getLogger(l).log(INFO, 'maximum spatial peak width = unknown')


    return
def reduce_orders(reduced, eta=None, arc=None):
    """Reduces each order in the frame.  
    
    Starting order is determined from a lookup table indexed by filter name.
    
    The grating equation is evaluated for y-axis location of the short wavelength end
    of the order on the detector.
    
    If the order is on the detector then extract_order() is called to cut out from the full
    frame a rectangular array of pixels containing the entire order plus padding.  
    
    Then, reduce_order() is called to reduce the order.
    reduce_order() returns an order object which is and instance of the Order class 
    and contains all of the reduced data for this order.  The order object is then
    appended to the list of order objects in the ReducedDataSet object representing 
    the current frame.
    
    After the first order that should be on the detector is found, processing continues
    through each order in descending order number, working toward higher pixel row numbers
    on the detector, until the first off-detector order is found.
    """

    for flatOrder in reduced.Flat.flatOrders:
        if flatOrder.valid is not True:
            continue

        logger.info('*' * 20 + ' ORDER {} '.format(flatOrder.orderNum) +
                    '*' * 20)

        #if flatOrder.orderNum != 32: continue #XXX
        #if flatOrder.orderNum != 33: continue #XXX
        #if flatOrder.orderNum != 37: continue #XXX
        #if flatOrder.orderNum != 68: continue #XXX

        order = Order.Order(reduced.frames,
                            reduced.baseNames,
                            flatOrder,
                            etaImg=reduced.etaImg)

        order.isPair = reduced.isPair

        for frame in order.frames:
            ### TESTING
            '''
            import matplotlib.pyplot as plt
            plt.figure()
            plt.imshow(reduced.objImg[frame], origin='lower')
            plt.axhline(flatOrder.highestPoint, c='r', ls='--')
            plt.axhline(flatOrder.lowestPoint, c='r', ls='--')
            plt.figure()
            plt.imshow(reduced.Flat.flatImg, origin='lower')
            plt.axhline(flatOrder.highestPoint, c='r', ls='--')
            plt.axhline(flatOrder.lowestPoint, c='r', ls='--')
            plt.show()
            '''
            ### TESTING

            ### TEST to mask out pixels outside of trace
            # Mask out the pixels above and below the trace
            #onOrderMask, offOrderMask = Flat.get_masks(
            #        flatOrder.cutout.shape, flatOrder.topEdgeTrace, flatOrder.botEdgeTrace)
            if float(flatOrder.lowestPoint) > float(flatOrder.cutoutPadding):
                onOrderMask, offOrderMask = Flat.get_masks(
                    flatOrder.cutout.shape, flatOrder.topEdgeTrace -
                    flatOrder.lowestPoint + flatOrder.cutoutPadding,
                    flatOrder.botEdgeTrace - flatOrder.lowestPoint +
                    flatOrder.cutoutPadding)
            else:
                onOrderMask, offOrderMask = Flat.get_masks(
                    flatOrder.cutout.shape, flatOrder.topEdgeTrace,
                    flatOrder.botEdgeTrace)
            ### TEST to mask out pixels outside of trace

            order.objCutout[frame] = np.array(
                image_lib.cut_out(reduced.objImg[frame],
                                  flatOrder.highestPoint,
                                  flatOrder.lowestPoint,
                                  flatOrder.cutoutPadding))
            '''
            import matplotlib.pyplot as plt
            plt.figure(64781)
            plt.imshow(order.objCutout[frame], origin='lower', aspect='auto')
            #plt.plot(np.arange(2048), topTrace, c='b', ls=':')
            #plt.plot(np.arange(2048), botTrace, c='r', ls=':')
            #plt.axhline(top, c='b', ls='--')
            #plt.axhline(bot, c='r', ls='--')
            plt.show(block=False)
            '''

            order.objCutout[frame] = np.ma.masked_array(order.objCutout[frame],
                                                        mask=offOrderMask)
            '''
            plt.figure(64782)
            plt.imshow(order.objCutout[frame], origin='lower', aspect='auto')
            #plt.plot(np.arange(2048), topTrace, c='b', ls=':')
            #plt.plot(np.arange(2048), botTrace, c='r', ls=':')
            #plt.axhline(top, c='b', ls='--')
            #plt.axhline(bot, c='r', ls='--')
            plt.show()
            '''

        if eta is not None:
            order.etaCutout = np.array(
                image_lib.cut_out(reduced.etaImg, flatOrder.highestPoint,
                                  flatOrder.lowestPoint,
                                  flatOrder.cutoutPadding))

        if arc is not None:
            order.arcCutout = np.array(
                image_lib.cut_out(reduced.arcImg, flatOrder.highestPoint,
                                  flatOrder.lowestPoint,
                                  flatOrder.cutoutPadding))

        order.integrationTime = reduced.getIntegrationTime(
        )  # used in noise calc

        try:

            # reduce order, i.e. rectify, extract spectra, identify sky lines
            reduce_order.reduce_order(order, eta=eta, arc=arc)

            # add reduced order to list of reduced orders in Reduced object
            reduced.orders.append(order)

        except DrpException.DrpException as e:
            logger.warning('failed to reduce order {}: {}'.format(
                str(flatOrder.orderNum), e.message))

        # end if order is on the detector
    # end for each order

    loggers = ['obj']
    if config.params['cmnd_line_mode'] is False:
        loggers.append('main')


#     for l in loggers:
#         logging.getLogger(l).log(INFO, 'n orders on the detector = {}'.format(n_orders_on_detector))
#         logging.getLogger(l).log(INFO, 'n orders reduced = {}'.format(len(reduced.orders)))

    if len(reduced.orders) == 0:
        return

    for l in loggers:
        reduced.snrMean = sum(reduced.orders[i].snr['A'] for i in range(len(reduced.orders))) / \
                len(reduced.orders)
        logging.getLogger(l).log(
            INFO,
            'mean signal-to-noise ratio = {:.1f}'.format(reduced.snrMean))

    snr = []
    for i in range(len(reduced.orders)):
        snr.append(reduced.orders[i].snr['A'])

    for l in loggers:
        reduced.snrMin = np.amin(snr)
        logging.getLogger(l).log(
            INFO,
            'minimum signal-to-noise ratio = {:.1f}'.format(reduced.snrMin))

        try:
            reduced.wMean = sum(abs(reduced.orders[i].gaussianParams['A'][2]) \
                    for i in range(len(reduced.orders))) /  len(reduced.orders)
            logging.getLogger(l).log(
                INFO, 'mean spatial peak width = {:.1f} pixels'.format(
                    reduced.wMean))
        except:
            logging.getLogger(l).log(logging.WARNING,
                                     'mean spatial peak width = unknown')

        w = []
        for i in range(len(reduced.orders)):
            if reduced.orders[i].gaussianParams['A'] is not None:
                w.append(reduced.orders[i].gaussianParams['A'][2])
        try:
            reduced.wMax = np.amax(w)
            logging.getLogger(l).log(
                INFO, 'maximum spatial peak width = {:.1f} pixels'.format(
                    reduced.wMax))
        except:
            logging.getLogger(l).error(
                'maximum spatial peak width cannot be determined')
            logging.getLogger(l).log(INFO,
                                     'maximum spatial peak width = unknown')

    return