|
| __init__ (self, detector=None, nAmp=0, **kwargs) |
|
| updateMetadata (self, setDate=False, **kwargs) |
|
| fromDetector (self, detector, coeffVector=None, coeffSqrVector=None) |
|
| fromDict (cls, dictionary) |
|
| toDict (self) |
|
| fromTable (cls, tableList) |
|
| toTable (self) |
|
| subtractCrosstalk (self, thisExposure, sourceExposure=None, crosstalkCoeffs=None, crosstalkCoeffsSqr=None, badPixels=["BAD"], minPixelToMask=45000, crosstalkStr="CROSSTALK", isTrimmed=False, backgroundMethod="None", doSqrCrosstalk=False) |
|
| subtractCrosstalkParallelOverscanRegion (self, thisExposure, crosstalkCoeffs=None, crosstalkCoeffsSqr=None, badPixels=["BAD"], crosstalkStr="CROSSTALK", detectorConfig=None, doSqrCrosstalk=False) |
|
Calibration of amp-to-amp crosstalk coefficients.
Parameters
----------
detector : `lsst.afw.cameraGeom.Detector`, optional
Detector to use to pull coefficients from.
nAmp : `int`, optional
Number of amplifiers to initialize.
log : `logging.Logger`, optional
Log to write messages to.
**kwargs :
Parameters to pass to parent constructor.
Notes
-----
The crosstalk attributes stored are:
hasCrosstalk : `bool`
Whether there is crosstalk defined for this detector.
nAmp : `int`
Number of amplifiers in this detector.
crosstalkShape : `tuple` [`int`, `int`]
A tuple containing the shape of the ``coeffs`` matrix. This
should be equivalent to (``nAmp``, ``nAmp``).
coeffs : `numpy.ndarray`
A matrix containing the crosstalk coefficients. coeff[i][j]
contains the coefficients to calculate the contribution
amplifier_j has on amplifier_i (each row[i] contains the
corrections for detector_i).
coeffErr : `numpy.ndarray`, optional
A matrix (as defined by ``coeffs``) containing the standard
distribution of the crosstalk measurements.
coeffNum : `numpy.ndarray`, optional
A matrix containing the number of pixel pairs used to measure
the ``coeffs`` and ``coeffErr``.
coeffValid : `numpy.ndarray`, optional
A matrix of Boolean values indicating if the coefficient is
valid, defined as abs(coeff) > coeffErr / sqrt(coeffNum).
coeffsSqr : `numpy.ndarray`, optional
A matrix containing potential quadratic crosstalk coefficients
(see e.g., Snyder+21, 2001.03223). coeffsSqr[i][j]
contains the coefficients to calculate the contribution
amplifier_j has on amplifier_i (each row[i] contains the
corrections for detector_i).
coeffErrSqr : `numpy.ndarray`, optional
A matrix (as defined by ``coeffsSqr``) containing the standard
distribution of the quadratic term of the crosstalk measurements.
interChip : `dict` [`numpy.ndarray`]
A dictionary keyed by detectorName containing ``coeffs``
matrices used to correct for inter-chip crosstalk with a
source on the detector indicated.
Version 1.1 adds quadratic coefficients, a matrix with the ratios
of amplifiers gains per detector, and a field to indicate the units
of the numerator and denominator of the source and target signals, with
"adu" meaning "ADU / ADU" and "electron" meaning "e- / e-".
Definition at line 41 of file crosstalk.py.
lsst.ip.isr.crosstalk.CrosstalkCalib.fromDetector |
( |
| self, |
|
|
| detector, |
|
|
| coeffVector = None, |
|
|
| coeffSqrVector = None ) |
Set calibration parameters from the detector.
Parameters
----------
detector : `lsst.afw.cameraGeom.Detector`
Detector to use to set parameters from.
coeffVector : `numpy.array`, optional
Use the detector geometry (bounding boxes and flip
information), but use ``coeffVector`` instead of the
output of ``detector.getCrosstalk()``.
coeffSqrVector : `numpy.array`, optional
Quadratic crosstalk coefficients.
Returns
-------
calib : `lsst.ip.isr.CrosstalkCalib`
The calibration constructed from the detector.
Reimplemented from lsst.ip.isr.calibType.IsrCalib.
Definition at line 160 of file crosstalk.py.
lsst.ip.isr.crosstalk.CrosstalkCalib.subtractCrosstalk |
( |
| self, |
|
|
| thisExposure, |
|
|
| sourceExposure = None, |
|
|
| crosstalkCoeffs = None, |
|
|
| crosstalkCoeffsSqr = None, |
|
|
| badPixels = ["BAD"], |
|
|
| minPixelToMask = 45000, |
|
|
| crosstalkStr = "CROSSTALK", |
|
|
| isTrimmed = False, |
|
|
| backgroundMethod = "None", |
|
|
| doSqrCrosstalk = False ) |
Subtract the crosstalk from thisExposure, optionally using a
different source.
We set the mask plane indicated by ``crosstalkStr`` in a target
amplifier for pixels in a source amplifier that exceed
``minPixelToMask``. Note that the correction is applied to all pixels
in the amplifier, but only those that have a substantial crosstalk
are masked with ``crosstalkStr``.
The uncorrected image is used as a template for correction. This is
good enough if the crosstalk is small (e.g., coefficients < ~ 1e-3),
but if it's larger you may want to iterate.
Parameters
----------
thisExposure : `lsst.afw.image.Exposure`
Exposure for which to subtract crosstalk.
sourceExposure : `lsst.afw.image.Exposure`, optional
Exposure to use as the source of the crosstalk. If not set,
thisExposure is used as the source (intra-detector crosstalk).
crosstalkCoeffs : `numpy.ndarray`, optional.
Coefficients to use to correct crosstalk.
crosstalkCoeffsSqr : `numpy.ndarray`, optional.
Quadratic coefficients to use to correct crosstalk.
badPixels : `list` of `str`, optional
Mask planes to ignore.
minPixelToMask : `float`, optional
Minimum pixel value (relative to the background level) in
source amplifier for which to set ``crosstalkStr`` mask plane
in target amplifier.
crosstalkStr : `str`, optional
Mask plane name for pixels greatly modified by crosstalk
(above minPixelToMask).
isTrimmed : `bool`, optional
The image is already trimmed.
This should no longer be needed once DM-15409 is resolved.
backgroundMethod : `str`, optional
Method used to subtract the background. "AMP" uses
amplifier-by-amplifier background levels, "DETECTOR" uses full
exposure/maskedImage levels. Any other value results in no
background subtraction.
doSqrCrosstalk: `bool`, optional
Should the quadratic crosstalk coefficients be used for the
crosstalk correction?
Notes
-----
For a given image I, we want to find the crosstalk subtrahend
image CT, such that
I_corrected = I - CT
The subtrahend image is the sum of all crosstalk contributions
that appear in I, so we can build it up by amplifier. Each
amplifier A in image I sees the contributions from all other
amplifiers B_v != A. For the current linear model, we set `sImage`
equal to the segment of the subtrahend image CT corresponding to
amplifier A, and then build it up as:
simage_linear = sum_v coeffsA_v * (B_v - bkg_v) where coeffsA_v
is the vector of crosstalk coefficients for sources that cause
images in amplifier A. The bkg_v term in this equation is
identically 0.0 for all cameras except obs_subaru (and is only
non-zero there for historical reasons).
To include the non-linear term, we can again add to the subtrahend
image using the same loop, as:
simage_nonlinear = sum_v (coeffsA_v * B_v) + (NLcoeffsA_v * B_v * B_v)
= sum_v linear_term_v + nonlinear_term_v
where coeffsA_v is the linear term, and NLcoeffsA_v are the quadratic
component. For LSSTCam, it has been observed that the linear_term_v >>
nonlinear_term_v.
Definition at line 533 of file crosstalk.py.
lsst.ip.isr.crosstalk.CrosstalkCalib.subtractCrosstalkParallelOverscanRegion |
( |
| self, |
|
|
| thisExposure, |
|
|
| crosstalkCoeffs = None, |
|
|
| crosstalkCoeffsSqr = None, |
|
|
| badPixels = ["BAD"], |
|
|
| crosstalkStr = "CROSSTALK", |
|
|
| detectorConfig = None, |
|
|
| doSqrCrosstalk = False ) |
Subtract crosstalk just from the parallel overscan region.
This assumes that serial overscan has been previously subtracted.
Parameters
----------
thisExposure : `lsst.afw.image.Exposure`
Exposure for which to subtract crosstalk.
crosstalkCoeffs : `numpy.ndarray`, optional.
Coefficients to use to correct crosstalk.
crosstalkCoeffsSqr : `numpy.ndarray`, optional.
Quadratic coefficients to use to correct crosstalk.
badPixels : `list` of `str`, optional
Mask planes to ignore.
crosstalkStr : `str`, optional
Mask plane name for pixels greatly modified by crosstalk
(above minPixelToMask).
detectorConfig : `lsst.ip.isr.overscanDetectorConfig`, optional
Per-amplifier configs to use.
doSqrCrosstalk: `bool`, optional
Should the quadratic crosstalk coefficients be used for the
crosstalk correction?
Definition at line 698 of file crosstalk.py.