lsst.ip.isr.measureCrosstalk Namespace Reference

Classes
class	MeasureCrosstalkConfig
class	MeasureCrosstalkTask

Functions
def	extractCrosstalkRatios (exposure, threshold=30000, badPixels=["SAT", BAD, INTRP)
def	measureCrosstalkCoefficients (ratios, rejIter=3, rejSigma=2.0)

Function Documentation

extractCrosstalkRatios()

def lsst.ip.isr.measureCrosstalk.extractCrosstalkRatios	(		exposure,
			threshold = 30000,
			badPixels = ["SAT",
			BAD,
			INTRP
	)

Extract crosstalk ratios between different amplifiers

For pixels above ``threshold``, we calculate the ratio between each
target amp and source amp. We return a list of ratios for each pixel
for each target/source combination, as a matrix of lists.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure for which to measure crosstalk.
threshold : `float`
    Lower limit on pixels for which we measure crosstalk.
badPixels : `list` of `str`
    Mask planes indicating a pixel is bad.

Returns
-------
ratios : `list` of `list` of `numpy.ndarray`
    A matrix of pixel arrays. ``ratios[i][j]`` is an array of
    the fraction of the ``j``-th amp present on the ``i``-th amp.
    The value is `None` for the diagonal elements.

Definition at line 42 of file measureCrosstalk.py.

def extractCrosstalkRatios(exposure, threshold=30000, badPixels=["SAT", "BAD", "INTRP"]):
    """Extract crosstalk ratios between different amplifiers

    For pixels above ``threshold``, we calculate the ratio between each
    target amp and source amp. We return a list of ratios for each pixel
    for each target/source combination, as a matrix of lists.

    Parameters
    ----------
    exposure : `lsst.afw.image.Exposure`
        Exposure for which to measure crosstalk.
    threshold : `float`
        Lower limit on pixels for which we measure crosstalk.
    badPixels : `list` of `str`
        Mask planes indicating a pixel is bad.

    Returns
    -------
    ratios : `list` of `list` of `numpy.ndarray`
        A matrix of pixel arrays. ``ratios[i][j]`` is an array of
        the fraction of the ``j``-th amp present on the ``i``-th amp.
        The value is `None` for the diagonal elements.
    """
    mi = exposure.getMaskedImage()
    FootprintSet(mi, Threshold(threshold), "DETECTED")
    detected = mi.getMask().getPlaneBitMask("DETECTED")
    bad = mi.getMask().getPlaneBitMask(badPixels)
    bg = calculateBackground(mi, badPixels + ["DETECTED"])

    ccd = exposure.getDetector()

    ratios = [[None for iAmp in ccd] for jAmp in ccd]

    for ii, iAmp in enumerate(ccd):
        iImage = mi[iAmp.getBBox()]
        iMask = iImage.mask.array
        select = (iMask & detected > 0) & (iMask & bad == 0) & np.isfinite(iImage.image.array)
        for jj, jAmp in enumerate(ccd):
            if ii == jj:
                continue
            jImage = extractAmp(mi.image, jAmp, iAmp.getReadoutCorner(), isTrimmed=True)
            ratios[jj][ii] = (jImage.array[select] - bg)/iImage.image.array[select]

    return ratios

measureCrosstalkCoefficients()

def lsst.ip.isr.measureCrosstalk.measureCrosstalkCoefficients	(		ratios,
			rejIter = 3,
			rejSigma = 2.0
	)

Measure crosstalk coefficients from the ratios

Given a list of ratios for each target/source amp combination,
we measure a robust mean and error.

The coefficient errors returned are the (robust) standard deviation of
the input ratios.

Parameters
----------
ratios : `list` of `list` of `numpy.ndarray`
    Matrix of arrays of ratios.
rejIter : `int`
    Number of rejection iterations.
rejSigma : `float`
    Rejection threshold (sigma).

Returns
-------
coeff : `numpy.ndarray`
    Crosstalk coefficients.
coeffErr : `numpy.ndarray`
    Crosstalk coefficient errors.
coeffNum : `numpy.ndarray`
    Number of pixels for each measurement.

Definition at line 88 of file measureCrosstalk.py.

def measureCrosstalkCoefficients(ratios, rejIter=3, rejSigma=2.0):
    """Measure crosstalk coefficients from the ratios

    Given a list of ratios for each target/source amp combination,
    we measure a robust mean and error.

    The coefficient errors returned are the (robust) standard deviation of
    the input ratios.

    Parameters
    ----------
    ratios : `list` of `list` of `numpy.ndarray`
        Matrix of arrays of ratios.
    rejIter : `int`
        Number of rejection iterations.
    rejSigma : `float`
        Rejection threshold (sigma).

    Returns
    -------
    coeff : `numpy.ndarray`
        Crosstalk coefficients.
    coeffErr : `numpy.ndarray`
        Crosstalk coefficient errors.
    coeffNum : `numpy.ndarray`
        Number of pixels for each measurement.
    """
    numAmps = len(ratios)
    assert all(len(rr) == numAmps for rr in ratios)

    coeff = np.zeros((numAmps, numAmps))
    coeffErr = np.zeros((numAmps, numAmps))
    coeffNum = np.zeros((numAmps, numAmps), dtype=int)

    for ii, jj in itertools.product(range(numAmps), range(numAmps)):
        if ii == jj:
            values = [0.0]
        else:
            values = np.array(ratios[ii][jj])
            values = values[np.abs(values) < 1.0]  # Discard unreasonable values

        coeffNum[ii][jj] = len(values)

        if len(values) == 0:
            coeff[ii][jj] = np.nan
            coeffErr[ii][jj] = np.nan
        else:
            if ii != jj:
                for rej in range(rejIter):
                    lo, med, hi = np.percentile(values, [25.0, 50.0, 75.0])
                    sigma = 0.741*(hi - lo)
                    good = np.abs(values - med) < rejSigma*sigma
                    if good.sum() == len(good):
                        break
                    values = values[good]

        coeff[ii][jj] = np.mean(values)
        coeffErr[ii][jj] = np.nan if coeffNum[ii][jj] == 1 else np.std(values)

    return coeff, coeffErr, coeffNum