lsst.ip.isr.isrTask.IsrTask Class Reference

Apply common instrument signature correction algorithms to a raw frame. More...

Inheritance diagram for lsst.ip.isr.isrTask.IsrTask:

Public Member Functions
def	__init__
	Constructor for IsrTask. More...
def	readIsrData
	Retrieve necessary frames for instrument signature removal. More...
def	run
	Perform instrument signature removal on an exposure. More...
def	runDataRef
	Perform instrument signature removal on a ButlerDataRef of a Sensor. More...
def	convertIntToFloat
def	biasCorrection
	Apply bias correction in place. More...
def	darkCorrection
	Apply dark correction in place. More...
def	updateVariance
	Set the variance plane based on the image plane, plus amplifier gain and read noise. More...
def	flatCorrection
	Apply flat correction in place. More...
def	getIsrExposure
	Retrieve a calibration dataset for removing instrument signature. More...
def	saturationDetection
	Detect saturated pixels and mask them using mask plane "SAT", in place. More...
def	saturationInterpolation
	Interpolate over saturated pixels, in place. More...
def	maskAndInterpDefect
	Mask defects using mask plane "BAD" and interpolate over them, in place. More...
def	maskAndInterpNan
	Mask NaNs using mask plane "UNMASKEDNAN" and interpolate over them, in place. More...
def	overscanCorrection
	Apply overscan correction, in place. More...

Static Public Attributes
	ConfigClass = IsrTaskConfig

Static Private Attributes
string	_DefaultName = "isr"

Detailed Description

Apply common instrument signature correction algorithms to a raw frame.

Contents

• Description
• Task initialization
• Inputs/Outputs to the run method
• Configuration parameters
• Debug variables
• A complete example of using IsrTask

Description

The process for correcting imaging data is very similar from camera to camera. This task provides a vanilla implementation of doing these corrections, including the ability to turn certain corrections off if they are not needed. The inputs to the primary method, run, are a raw exposure to be corrected and the calibration data products. The raw input is a single chip sized mosaic of all amps including overscans and other non-science pixels. The method runDataRef() is intended for use by a lsst.pipe.base.cmdLineTask.CmdLineTask and takes as input only a daf.persistence.butlerSubset.ButlerDataRef. This task may not meet all needs and it is expected that it will be subclassed for specific applications.

Task initialization

Constructor for IsrTask.

Parameters

[in]	*args	– a list of positional arguments passed on to the Task constructor
[in]	**kwargs	– a dictionary of keyword arguments passed on to the Task constructor Call the lsst.pipe.base.task.Task.__init__ method Then setup the assembly and fringe correction subtasks

Inputs/Outputs to the run method

Perform instrument signature removal on an exposure. Steps include:

• Detect saturation, apply overscan correction, bias, dark and flat
• Perform CCD assembly
• Interpolate over defects, saturated pixels and all NaNs

Parameters

[in]	ccdExposure	– lsst.afw.image.exposure of detector data
[in]	bias	– exposure of bias frame
[in]	dark	– exposure of dark frame
[in]	flat	– exposure of flatfield
[in]	defects	– list of detects
[in]	fringes	– exposure of fringe frame or list of fringe exposure

Returns

a pipeBase.Struct with field:

• exposure

Configuration parameters

See IsrTaskConfig

Debug variables

The command line task interface supports a flag –debug, -d to import debug.py from your PYTHONPATH; see Using lsstDebug to control debugging output for more about debug.py files.

The available variables in IsrTask are:

display

A dictionary containing debug point names as keys with frame number as value. Valid keys are:

postISRCCD

display exposure after ISR has been applied

For example, put something like

import lsstDebug
def DebugInfo(name):
    di = lsstDebug.getInfo(name)        # N.b. lsstDebug.Info(name) would call us recursively
    if name == "lsst.ip.isr.isrTask":
        di.display = {'postISRCCD':2}
    return di
lsstDebug.Info = DebugInfo

into your debug.py file and run the commandline task with the –debug flag.

A complete example of using IsrTask

This code is in runIsrTask.py in the examples directory and can be run as e.g.

python examples/runIsrTask.py

# optional arguments:
# --debug, -d  Load debug.py?
# --ds9        Display the result?
# --write      Write the result?

---

Stepping through the example:

Import the task. There are other imports. Read the source file for more info.

from lsst.ip.isr import IsrTask
import exampleUtils

Create the raw input data with the help of some utilities in exampleUtils.py also in the examples directory. We will only do overscan, dark and flat correction. The data are constructed by hand so that all effects will be corrected for essentially perfectly.

    DARKVAL = 2. #e-/sec
    OSCAN = 1000. #DN
    GRADIENT = .10
    EXPTIME = 15 #seconds
    DARKEXPTIME = 40. #seconds

    darkExposure = exampleUtils.makeDark(DARKVAL, DARKEXPTIME)
    flatExposure = exampleUtils.makeFlat(GRADIENT)
    rawExposure = exampleUtils.makeRaw(DARKVAL, OSCAN, GRADIENT, EXPTIME)

The above numbers can be changed to modify the gradient in the flat, for example. For the parameters in this particular example, the image after ISR will be a constant 5000 counts (with some variation in floating point represenation).

Note

Alternatively, images can be read from disk, either using the Butler or manually:

import lsst.afw.image as afwImage
darkExposure = afwImage.ExposureF("/path/to/dark.fits")
flatExposure = afwImage.ExposureF("/path/to/flat.fits")
rawExposure = afwImage.ExposureF("/path/to/raw.fits")

In order to perform overscanCorrection IsrTask.run() requires Exposures which have a lsst.afw.cameraGeom.Detector. Detector objects describe details such as data dimensions, number of amps, orientation and overscan dimensions. If requesting images from the Butler, Exposures will automatically have detector information. If running IsrTask on arbitrary images from a camera without an obs_ package, a lsst.afw.cameraGeom.Detector can be generated using lsst.afw.cameraGeom.fitsUtils.DetectorBuilder and set by calling

rawExposure.setDetector(myDetectorObject)

See lsst.afw.cameraGeom.fitsUtils.DetectorBuilder for more details.

The updateVariance and saturationDetection steps are not run for Exposures without a lsst.afw.cameraGeom.Detector, unless IsrTaskConfig.gain, IsrTaskConfig.readNoise, and/or IsrTaskConfig.saturation are set in the config, in which case they are applied to the entire image rather than per amp.

Construct the task and set some config parameters. Specifically, we don't want to do zero or fringe correction. We also don't want the assembler messing with the gain.

    #Create the isr task with modified config
    isrConfig = IsrTask.ConfigClass()
    isrConfig.doBias = False #We didn't make a zero frame
    isrConfig.doDark = True
    isrConfig.doFlat = True
    isrConfig.doFringe = False #There is no fringe frame for this example

    isrConfig.assembleCcd.doRenorm = False #We'll take care of gain in the flats
    isrConfig.assembleCcd.setGain = False 
    isrTask = IsrTask(config=isrConfig)

Finally, run the exposures through ISR.

    output = isrTask.run(rawExposure, dark=darkExposure, flat=flatExposure)

---

Definition at line 176 of file isrTask.py.

Constructor & Destructor Documentation

def lsst.ip.isr.isrTask.IsrTask.__init__	(		self,
			args,
			kwargs
	)

Constructor for IsrTask.

Parameters

[in]	*args	– a list of positional arguments passed on to the Task constructor
[in]	**kwargs	– a dictionary of keyword arguments passed on to the Task constructor Call the lsst.pipe.base.task.Task.__init__ method Then setup the assembly and fringe correction subtasks

Definition at line 317 of file isrTask.py.

    def __init__(self, *args, **kwargs):
        '''!Constructor for IsrTask
        \param[in] *args -- a list of positional arguments passed on to the Task constructor
        \param[in] **kwargs -- a dictionary of keyword arguments passed on to the Task constructor
        Call the lsst.pipe.base.task.Task.__init__ method
        Then setup the assembly and fringe correction subtasks
        '''
        pipeBase.Task.__init__(self, *args, **kwargs)
        self.makeSubtask("assembleCcd")
        self.makeSubtask("fringe")