Inheritance diagram for lsst.cp.pipe.measureCrosstalk.CrosstalkExtractTask:

Public Member Functions
def	run (self, inputExp, sourceExps=[])

def	debugView (self, stepname, exposure)

def	debugPixels (self, stepname, pixelsIn, pixelsOut, sourceName, targetName)

Static Public Attributes
	ConfigClass = CrosstalkExtractConfig

Detailed Description

Task to measure pixel ratios to find crosstalk.

Definition at line 127 of file measureCrosstalk.py.

Member Function Documentation

◆ debugPixels()

def lsst.cp.pipe.measureCrosstalk.CrosstalkExtractTask.debugPixels	(	self,
		stepname,
		pixelsIn,
		pixelsOut,
		sourceName,
		targetName
	)

Utility function to examine the CT ratio pixel values.

Parameters
----------
stepname : `str`
    State of processing to view.
pixelsIn : `np.ndarray`
    Pixel values from the potential crosstalk source.
pixelsOut : `np.ndarray`
    Pixel values from the potential crosstalk target.
sourceName : `str`
    Source amplifier name
targetName : `str`
    Target amplifier name

Definition at line 282 of file measureCrosstalk.py.

     def debugPixels(self, stepname, pixelsIn, pixelsOut, sourceName, targetName):
         """Utility function to examine the CT ratio pixel values.
  
         Parameters
         ----------
         stepname : `str`
             State of processing to view.
         pixelsIn : `np.ndarray`
             Pixel values from the potential crosstalk source.
         pixelsOut : `np.ndarray`
             Pixel values from the potential crosstalk target.
         sourceName : `str`
             Source amplifier name
         targetName : `str`
             Target amplifier name
         """
         frame = getDebugFrame(self._display, stepname)
         if frame:
             import matplotlib.pyplot as plt
             figure = plt.figure(1)
             figure.clear()
  
             axes = figure.add_axes((0.1, 0.1, 0.8, 0.8))
             axes.plot(pixelsIn, pixelsOut / pixelsIn, 'k+')
             plt.xlabel("Source amplifier pixel value")
             plt.ylabel("Measured pixel ratio")
             plt.title(f"(Source {sourceName} -> Target {targetName}) median ratio: "
                       f"{(np.median(pixelsOut / pixelsIn))}")
             figure.show()
  
             prompt = "Press Enter to continue: "
             while True:
                 ans = input(prompt).lower()
                 if ans in ("", "c",):
                     break
             plt.close()
  
  

◆ debugView()

def lsst.cp.pipe.measureCrosstalk.CrosstalkExtractTask.debugView	(	self,
		stepname,
		exposure
	)

Utility function to examine the image being processed.

Parameters
----------
stepname : `str`
    State of processing to view.
exposure : `lsst.afw.image.Exposure`
    Exposure to view.

Definition at line 260 of file measureCrosstalk.py.

     def debugView(self, stepname, exposure):
         """Utility function to examine the image being processed.
  
         Parameters
         ----------
         stepname : `str`
             State of processing to view.
         exposure : `lsst.afw.image.Exposure`
             Exposure to view.
         """
         frame = getDebugFrame(self._display, stepname)
         if frame:
             display = getDisplay(frame)
             display.scale('asinh', 'zscale')
             display.mtv(exposure)
  
             prompt = "Press Enter to continue: "
             while True:
                 ans = input(prompt).lower()
                 if ans in ("", "c",):
                     break
  

◆ run()

def lsst.cp.pipe.measureCrosstalk.CrosstalkExtractTask.run	(	self,
		inputExp,
		sourceExps = `[]`
	)

Measure pixel ratios between amplifiers in inputExp.

Extract crosstalk ratios between different amplifiers.

For pixels above ``config.threshold``, we calculate the ratio
between each background-subtracted target amp and the source
amp. We return a list of ratios for each pixel for each
target/source combination, as nested dictionary containing the
ratio.

Parameters
----------
inputExp : `lsst.afw.image.Exposure`
    Input exposure to measure pixel ratios on.
sourceExp : `list` [`lsst.afw.image.Exposure`], optional
    List of chips to use as sources to measure inter-chip
    crosstalk.

Returns
-------
results : `lsst.pipe.base.Struct`
    The results struct containing:

    ``outputRatios`` : `dict` [`dict` [`dict` [`dict` [`list`]]]]
         A catalog of ratio lists.  The dictionaries are
         indexed such that:
         outputRatios[targetChip][sourceChip][targetAmp][sourceAmp]
         contains the ratio list for that combination.
    ``outputFluxes`` : `dict` [`dict` [`list`]]
         A catalog of flux lists.  The dictionaries are
         indexed such that:
         outputFluxes[sourceChip][sourceAmp]
         contains the flux list used in the outputRatios.

Notes
-----
The lsstDebug.Info() method can be rewritten for __name__ =
`lsst.cp.pipe.measureCrosstalk`, and supports the parameters:

debug.display['extract'] : `bool`
    Display the exposure under consideration, with the pixels used
    for crosstalk measurement indicated by the DETECTED mask plane.
debug.display['pixels'] : `bool`
    Display a plot of the ratio calculated for each pixel used in this
    exposure, split by amplifier pairs.  The median value is listed
    for reference.

Definition at line 134 of file measureCrosstalk.py.

     def run(self, inputExp, sourceExps=[]):
         """Measure pixel ratios between amplifiers in inputExp.
  
         Extract crosstalk ratios between different amplifiers.
  
         For pixels above ``config.threshold``, we calculate the ratio
         between each background-subtracted target amp and the source
         amp. We return a list of ratios for each pixel for each
         target/source combination, as nested dictionary containing the
         ratio.
  
         Parameters
         ----------
         inputExp : `lsst.afw.image.Exposure`
             Input exposure to measure pixel ratios on.
         sourceExp : `list` [`lsst.afw.image.Exposure`], optional
             List of chips to use as sources to measure inter-chip
             crosstalk.
  
         Returns
         -------
         results : `lsst.pipe.base.Struct`
             The results struct containing:
  
             ``outputRatios`` : `dict` [`dict` [`dict` [`dict` [`list`]]]]
                  A catalog of ratio lists.  The dictionaries are
                  indexed such that:
                  outputRatios[targetChip][sourceChip][targetAmp][sourceAmp]
                  contains the ratio list for that combination.
             ``outputFluxes`` : `dict` [`dict` [`list`]]
                  A catalog of flux lists.  The dictionaries are
                  indexed such that:
                  outputFluxes[sourceChip][sourceAmp]
                  contains the flux list used in the outputRatios.
  
         Notes
         -----
         The lsstDebug.Info() method can be rewritten for __name__ =
         `lsst.cp.pipe.measureCrosstalk`, and supports the parameters:
  
         debug.display['extract'] : `bool`
             Display the exposure under consideration, with the pixels used
             for crosstalk measurement indicated by the DETECTED mask plane.
         debug.display['pixels'] : `bool`
             Display a plot of the ratio calculated for each pixel used in this
             exposure, split by amplifier pairs.  The median value is listed
             for reference.
         """
         outputRatios = defaultdict(lambda: defaultdict(dict))
         outputFluxes = defaultdict(lambda: defaultdict(dict))
  
         threshold = self.config.threshold
         badPixels = list(self.config.badMask)
  
         targetDetector = inputExp.getDetector()
         targetChip = targetDetector.getName()
  
         # Always look at the target chip first, then go to any other supplied exposures.
         sourceExtractExps = [inputExp]
         sourceExtractExps.extend(sourceExps)
  
         self.log.info("Measuring full detector background for target: %s", targetChip)
         targetIm = inputExp.getMaskedImage()
         FootprintSet(targetIm, Threshold(threshold), "DETECTED")
         detected = targetIm.getMask().getPlaneBitMask("DETECTED")
         bg = CrosstalkCalib.calculateBackground(targetIm, badPixels + ["DETECTED"])
  
         self.debugView('extract', inputExp)
  
         for sourceExp in sourceExtractExps:
             sourceDetector = sourceExp.getDetector()
             sourceChip = sourceDetector.getName()
             sourceIm = sourceExp.getMaskedImage()
             bad = sourceIm.getMask().getPlaneBitMask(badPixels)
             self.log.info("Measuring crosstalk from source: %s", sourceChip)
  
             if sourceExp != inputExp:
                 FootprintSet(sourceIm, Threshold(threshold), "DETECTED")
                 detected = sourceIm.getMask().getPlaneBitMask("DETECTED")
  
             # The dictionary of amp-to-amp ratios for this pair of source->target detectors.
             ratioDict = defaultdict(lambda: defaultdict(list))
             extractedCount = 0
  
             for sourceAmp in sourceDetector:
                 sourceAmpName = sourceAmp.getName()
                 sourceAmpBBox = sourceAmp.getBBox() if self.config.isTrimmed else sourceAmp.getRawDataBBox()
                 sourceAmpImage = sourceIm[sourceAmpBBox]
                 sourceMask = sourceAmpImage.mask.array
                 select = ((sourceMask & detected > 0)
                           & (sourceMask & bad == 0)
                           & np.isfinite(sourceAmpImage.image.array))
                 count = np.sum(select)
                 self.log.debug("  Source amplifier: %s", sourceAmpName)
  
                 outputFluxes[sourceChip][sourceAmpName] = sourceAmpImage.image.array[select].tolist()
  
                 for targetAmp in targetDetector:
                     # iterate over targetExposure
                     targetAmpName = targetAmp.getName()
                     if sourceAmpName == targetAmpName and sourceChip == targetChip:
                         ratioDict[sourceAmpName][targetAmpName] = []
                         continue
                     self.log.debug("    Target amplifier: %s", targetAmpName)
  
                     targetAmpImage = CrosstalkCalib.extractAmp(targetIm.image,
                                                                targetAmp, sourceAmp,
                                                                isTrimmed=self.config.isTrimmed)
                     ratios = (targetAmpImage.array[select] - bg)/sourceAmpImage.image.array[select]
                     ratioDict[targetAmpName][sourceAmpName] = ratios.tolist()
                     extractedCount += count
  
                     self.debugPixels('pixels',
                                      sourceAmpImage.image.array[select],
                                      targetAmpImage.array[select] - bg,
                                      sourceAmpName, targetAmpName)
  
             self.log.info("Extracted %d pixels from %s -> %s (targetBG: %f)",
                           extractedCount, sourceChip, targetChip, bg)
             outputRatios[targetChip][sourceChip] = ratioDict
  
         return pipeBase.Struct(
             outputRatios=ddict2dict(outputRatios),
             outputFluxes=ddict2dict(outputFluxes)
         )
  

Member Data Documentation

◆ ConfigClass

lsst.cp.pipe.measureCrosstalk.CrosstalkExtractTask.ConfigClass = CrosstalkExtractConfig

static

Definition at line 131 of file measureCrosstalk.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.6.0/Linux64/cp_pipe/22.0.1-18-gb17765a+2264247a6b/python/lsst/cp/pipe/measureCrosstalk.py

Public Member Functions