Inheritance diagram for lsst.ip.isr.deferredCharge.DeferredChargeTask:

Public Member Functions
	run (self, exposure, ctiCalib, gains=None)

Static Public Member Functions
	flipData (ampData, amp)

	local_offset_inverse (inputArr, drift_scale, decay_time, num_previous_pixels=15)

	local_trap_inverse (inputArr, trap, global_cti=0.0, num_previous_pixels=6)

Static Public Attributes
	ConfigClass = DeferredChargeConfig

Static Protected Attributes
str	_DefaultName = 'isrDeferredCharge'

Detailed Description

Task to correct an exposure for charge transfer inefficiency.

This uses the methods described by Snyder et al. 2021, Journal of
Astronimcal Telescopes, Instruments, and Systems, 7,
048002. doi:10.1117/1.JATIS.7.4.048002 (Snyder+21).

Definition at line 1189 of file deferredCharge.py.

Member Function Documentation

◆ flipData()

lsst.ip.isr.deferredCharge.DeferredChargeTask.flipData	(		ampData,
			amp )

static

Flip data array such that readout corner is at lower-left.

Parameters
----------
ampData : `numpy.ndarray`, (nx, ny)
    Image data to flip.
amp : `lsst.afw.cameraGeom.Amplifier`
    Amplifier to get readout corner information.

Returns
-------
ampData : `numpy.ndarray`, (nx, ny)
    Flipped image data.

Definition at line 1283 of file deferredCharge.py.

    def flipData(ampData, amp):
        """Flip data array such that readout corner is at lower-left.
 
        Parameters
        ----------
        ampData : `numpy.ndarray`, (nx, ny)
            Image data to flip.
        amp : `lsst.afw.cameraGeom.Amplifier`
            Amplifier to get readout corner information.
 
        Returns
        -------
        ampData : `numpy.ndarray`, (nx, ny)
            Flipped image data.
        """
        X_FLIP = {ReadoutCorner.LL: False,
                  ReadoutCorner.LR: True,
                  ReadoutCorner.UL: False,
                  ReadoutCorner.UR: True}
        Y_FLIP = {ReadoutCorner.LL: False,
                  ReadoutCorner.LR: False,
                  ReadoutCorner.UL: True,
                  ReadoutCorner.UR: True}
 
        if X_FLIP[amp.getReadoutCorner()]:
            ampData = np.fliplr(ampData)
        if Y_FLIP[amp.getReadoutCorner()]:
            ampData = np.flipud(ampData)
 
        return ampData
 

◆ local_offset_inverse()

lsst.ip.isr.deferredCharge.DeferredChargeTask.local_offset_inverse	(	inputArr,
		drift_scale,
		decay_time,
		num_previous_pixels = 15 )

static

Remove CTI effects from local offsets.

    This implements equation 10 of Snyder+21.  For an image with
    CTI, s'(m, n), the correction factor is equal to the maximum
    value of the set of:

    .. code-block::

        {A_L s'(m, n - j) exp(-j t / \tau_L)}_j=0^jmax

    Parameters
    ----------
    inputArr : `numpy.ndarray`, (nx, ny)
        Input image data to correct.
    drift_scale : `float`
        Drift scale (Snyder+21 A_L value) to use in correction.
    decay_time : `float`
        Decay time (Snyder+21 \tau_L) of the correction.
    num_previous_pixels : `int`, optional
        Number of previous pixels to use for correction.  As the
        CTI has an exponential decay, this essentially truncates
        the correction where that decay scales the input charge to
        near zero.

    Returns
    -------
    outputArr : `numpy.ndarray`, (nx, ny)
        Corrected image data.

Definition at line 1315 of file deferredCharge.py.

    def local_offset_inverse(inputArr, drift_scale, decay_time, num_previous_pixels=15):
        r"""Remove CTI effects from local offsets.
 
        This implements equation 10 of Snyder+21.  For an image with
        CTI, s'(m, n), the correction factor is equal to the maximum
        value of the set of:
 
        .. code-block::
 
            {A_L s'(m, n - j) exp(-j t / \tau_L)}_j=0^jmax
 
        Parameters
        ----------
        inputArr : `numpy.ndarray`, (nx, ny)
            Input image data to correct.
        drift_scale : `float`
            Drift scale (Snyder+21 A_L value) to use in correction.
        decay_time : `float`
            Decay time (Snyder+21 \tau_L) of the correction.
        num_previous_pixels : `int`, optional
            Number of previous pixels to use for correction.  As the
            CTI has an exponential decay, this essentially truncates
            the correction where that decay scales the input charge to
            near zero.
 
        Returns
        -------
        outputArr : `numpy.ndarray`, (nx, ny)
            Corrected image data.
        """
        r = np.exp(-1/decay_time)
        Ny, Nx = inputArr.shape
 
        # j = 0 term:
        offset = np.zeros((num_previous_pixels, Ny, Nx))
        offset[0, :, :] = drift_scale*np.maximum(0, inputArr)
 
        # j = 1..jmax terms:
        for n in range(1, num_previous_pixels):
            offset[n, :, n:] = drift_scale*np.maximum(0, inputArr[:, :-n])*(r**n)
 
        Linv = np.amax(offset, axis=0)
        outputArr = inputArr - Linv
 
        return outputArr
 

◆ local_trap_inverse()

lsst.ip.isr.deferredCharge.DeferredChargeTask.local_trap_inverse	(	inputArr,
		trap,
		global_cti = 0.0,
		num_previous_pixels = 6 )

static

Apply localized trapping inverse operator to pixel signals.

    This implements equation 13 of Snyder+21.  For an image with
    CTI, s'(m, n), the correction factor is equal to the maximum
    value of the set of:

    .. code-block::

        {A_L s'(m, n - j) exp(-j t / \tau_L)}_j=0^jmax

    Parameters
    ----------
    inputArr : `numpy.ndarray`, (nx, ny)
        Input image data to correct.
    trap : `lsst.ip.isr.SerialTrap`
        Serial trap describing the capture and release of charge.
    global_cti: `float`
        Mean charge transfer inefficiency, b from Snyder+21.
    num_previous_pixels : `int`, optional
        Number of previous pixels to use for correction.

    Returns
    -------
    outputArr : `numpy.ndarray`, (nx, ny)
        Corrected image data.

Definition at line 1362 of file deferredCharge.py.

    def local_trap_inverse(inputArr, trap, global_cti=0.0, num_previous_pixels=6):
        r"""Apply localized trapping inverse operator to pixel signals.
 
        This implements equation 13 of Snyder+21.  For an image with
        CTI, s'(m, n), the correction factor is equal to the maximum
        value of the set of:
 
        .. code-block::
 
            {A_L s'(m, n - j) exp(-j t / \tau_L)}_j=0^jmax
 
        Parameters
        ----------
        inputArr : `numpy.ndarray`, (nx, ny)
            Input image data to correct.
        trap : `lsst.ip.isr.SerialTrap`
            Serial trap describing the capture and release of charge.
        global_cti: `float`
            Mean charge transfer inefficiency, b from Snyder+21.
        num_previous_pixels : `int`, optional
            Number of previous pixels to use for correction.
 
        Returns
        -------
        outputArr : `numpy.ndarray`, (nx, ny)
            Corrected image data.
 
        """
        Ny, Nx = inputArr.shape
        a = 1 - global_cti
        r = np.exp(-1/trap.emission_time)
 
        # Estimate trap occupancies during readout
        trap_occupancy = np.zeros((num_previous_pixels, Ny, Nx))
        for n in range(num_previous_pixels):
            trap_occupancy[n, :, n+1:] = trap.capture(np.maximum(0, inputArr))[:, :-(n+1)]*(r**n)
        trap_occupancy = np.amax(trap_occupancy, axis=0)
 
        # Estimate captured charge
        C = trap.capture(np.maximum(0, inputArr)) - trap_occupancy*r
        C[C < 0] = 0.
 
        # Estimate released charge
        R = np.zeros(inputArr.shape)
        R[:, 1:] = trap_occupancy[:, 1:]*(1-r)
        T = R - C
 
        outputArr = inputArr - a*T
 
        return outputArr

◆ run()

lsst.ip.isr.deferredCharge.DeferredChargeTask.run	(	self,
		exposure,
		ctiCalib,
		gains = None )

Correct deferred charge/CTI issues.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to correct the deferred charge on.
ctiCalib : `lsst.ip.isr.DeferredChargeCalib`
    Calibration object containing the charge transfer
    inefficiency model.
gains : `dict` [`str`, `float`]
    A dictionary, keyed by amplifier name, of the gains to
    use.  If gains is None, the nominal gains in the amplifier
    object are used.

Returns
-------
exposure : `lsst.afw.image.Exposure`
    The corrected exposure.

Notes
-------
This task will read the exposure metadata and determine if
applying gains if necessary. The correction takes place in
units of electrons. If bootstrapping, the gains used
will just be 1.0. and the input/output units will stay in
adu. If the input image is in adu, the output image will be
in units of electrons. If the input image is in electron,
the output image will be in electron.

Definition at line 1199 of file deferredCharge.py.

    def run(self, exposure, ctiCalib, gains=None):
        """Correct deferred charge/CTI issues.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure to correct the deferred charge on.
        ctiCalib : `lsst.ip.isr.DeferredChargeCalib`
            Calibration object containing the charge transfer
            inefficiency model.
        gains : `dict` [`str`, `float`]
            A dictionary, keyed by amplifier name, of the gains to
            use.  If gains is None, the nominal gains in the amplifier
            object are used.
 
        Returns
        -------
        exposure : `lsst.afw.image.Exposure`
            The corrected exposure.
 
        Notes
        -------
        This task will read the exposure metadata and determine if
        applying gains if necessary. The correction takes place in
        units of electrons. If bootstrapping, the gains used
        will just be 1.0. and the input/output units will stay in
        adu. If the input image is in adu, the output image will be
        in units of electrons. If the input image is in electron,
        the output image will be in electron.
        """
        image = exposure.getMaskedImage().image
        detector = exposure.getDetector()
 
        # Get the image and overscan units.
        imageUnits = exposure.getMetadata().get("LSST ISR UNITS")
 
        # The deferred charge correction assumes that everything is in
        # electron units. Make it so:
        applyGains = False
        if imageUnits == "adu":
            applyGains = True
 
        # If we need to convert the image to electrons, check that gains
        # were supplied. CTI should not be solved or corrected without
        # supplied gains.
        if applyGains and gains is None:
            raise RuntimeError("No gains supplied for deferred charge correction.")
 
        with gainContext(exposure, image, apply=applyGains, gains=gains, isTrimmed=False):
            # Both the image and the overscan are in electron units.
            for amp in detector.getAmplifiers():
                ampName = amp.getName()
 
                ampImage = image[amp.getRawBBox()]
                if self.config.zeroUnusedPixels:
                    # We don't apply overscan subtraction, so zero these
                    # out for now.
                    ampImage[amp.getRawParallelOverscanBBox()].array[:, :] = 0.0
                    ampImage[amp.getRawSerialPrescanBBox()].array[:, :] = 0.0
 
                # The algorithm expects that the readout corner is in
                # the lower left corner.  Flip it to be so:
                ampData = self.flipData(ampImage.array, amp)
 
                if ctiCalib.driftScale[ampName] > 0.0:
                    correctedAmpData = self.local_offset_inverse(ampData,
                                                                 ctiCalib.driftScale[ampName],
                                                                 ctiCalib.decayTime[ampName],
                                                                 self.config.nPixelOffsetCorrection)
                else:
                    correctedAmpData = ampData.copy()
 
                correctedAmpData = self.local_trap_inverse(correctedAmpData,
                                                           ctiCalib.serialTraps[ampName],
                                                           ctiCalib.globalCti[ampName],
                                                           self.config.nPixelTrapCorrection)
 
                # Undo flips here.  The method is symmetric.
                correctedAmpData = self.flipData(correctedAmpData, amp)
                image[amp.getRawBBox()].array[:, :] = correctedAmpData[:, :]
 
        return exposure
 

Member Data Documentation

◆ _DefaultName

str lsst.ip.isr.deferredCharge.DeferredChargeTask._DefaultName = 'isrDeferredCharge'

staticprotected

Definition at line 1197 of file deferredCharge.py.

◆ ConfigClass

lsst.ip.isr.deferredCharge.DeferredChargeTask.ConfigClass = DeferredChargeConfig

static

Definition at line 1196 of file deferredCharge.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/ip_isr/g436fd98eb5+bdc6fcdd04/python/lsst/ip/isr/deferredCharge.py

Public Member Functions

Static Public Member Functions

Static Public Attributes

Static Protected Attributes

Detailed Description

Member Function Documentation

◆ flipData()

◆ local_offset_inverse()

◆ local_trap_inverse()

◆ run()

Member Data Documentation

◆ _DefaultName

◆ ConfigClass