lsst.ip.isr.ampOffset.AmpOffsetTask Class Reference

Inheritance diagram for lsst.ip.isr.ampOffset.AmpOffsetTask:

Public Member Functions
	__init__ (self, *args, **kwargs)
	run (self, exposure)
	getAmpAssociations (self, amps)
	getNeighbors (self, ampIds, ampId)
	getAmpOffsets (self, im, amps, associations, sides)
	getAmpEdges (self, im, amps, ampSides)
	getInterfaceOffset (self, ampNameA, ampNameB, edgeA, edgeB)

Public Attributes
int	shortAmpSide = 0
	ampDims = ampDims[0]
dict	interfaceLengthLookupBySide = {i: self.ampDims[i % 2] for i in range(4)}

Static Public Attributes
	ConfigClass = AmpOffsetConfig

Static Protected Attributes
str	_DefaultName = "isrAmpOffset"

Detailed Description

Calculate and apply amp offset corrections to an exposure.

Definition at line 130 of file ampOffset.py.

Constructor & Destructor Documentation

__init__()

lsst.ip.isr.ampOffset.AmpOffsetTask.__init__	(		self,
		*	args,
		**	kwargs )

Definition at line 136 of file ampOffset.py.

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Always load background subtask, even if doBackground=False;
        # this allows for default plane bit masks to be defined.
        self.makeSubtask("background")
        if self.config.doDetection:
            self.makeSubtask("detection")
        # Initialize all of the instance variables here.
        self.shortAmpSide = 0
 

Member Function Documentation

getAmpAssociations()

lsst.ip.isr.ampOffset.AmpOffsetTask.getAmpAssociations	(		self,
			amps )

Determine amp geometry and amp associations from a list of
amplifiers.

Parse an input list of amplifiers to determine the layout of amps
within a detector, and identify all amp sides (i.e., the
horizontal and vertical junctions between amps).

Returns a matrix with a shape corresponding to the geometry of the amps
in the detector.

Parameters
----------
amps : `list` [`lsst.afw.cameraGeom.Amplifier`]
    List of amplifier objects used to deduce associations.

Returns
-------
ampAssociations : `numpy.ndarray`
    An N x N matrix (N = number of amplifiers) that illustrates the
    connections between amplifiers within the detector layout. Each row
    and column index corresponds to the ampIds of a specific pair of
    amplifiers, and the matrix elements indicate their associations as
    follows:

    * 0: No association
    * -1: Association exists (direction specified in the ampSides
      matrix)
    * n >= 1: Diagonal elements indicate the number of neighboring
      amplifiers for the corresponding ampId==row==column number.

ampSides : `numpy.ndarray`
    An N x N matrix (N = the number of amplifiers) representing the amp
    side information corresponding to the `ampAssociations`
    matrix. The elements are integers defined as below:

    * -1: No side due to no association or the same amp (diagonals)
    * 0: Side on the bottom
    * 1: Side on the right
    * 2: Side on the top
    * 3: Side on the left

Definition at line 284 of file ampOffset.py.

    def getAmpAssociations(self, amps):
        """Determine amp geometry and amp associations from a list of
        amplifiers.
 
        Parse an input list of amplifiers to determine the layout of amps
        within a detector, and identify all amp sides (i.e., the
        horizontal and vertical junctions between amps).
 
        Returns a matrix with a shape corresponding to the geometry of the amps
        in the detector.
 
        Parameters
        ----------
        amps : `list` [`lsst.afw.cameraGeom.Amplifier`]
            List of amplifier objects used to deduce associations.
 
        Returns
        -------
        ampAssociations : `numpy.ndarray`
            An N x N matrix (N = number of amplifiers) that illustrates the
            connections between amplifiers within the detector layout. Each row
            and column index corresponds to the ampIds of a specific pair of
            amplifiers, and the matrix elements indicate their associations as
            follows:
 
            * 0: No association
            * -1: Association exists (direction specified in the ampSides
              matrix)
            * n >= 1: Diagonal elements indicate the number of neighboring
              amplifiers for the corresponding ampId==row==column number.
 
        ampSides : `numpy.ndarray`
            An N x N matrix (N = the number of amplifiers) representing the amp
            side information corresponding to the `ampAssociations`
            matrix. The elements are integers defined as below:
 
            * -1: No side due to no association or the same amp (diagonals)
            * 0: Side on the bottom
            * 1: Side on the right
            * 2: Side on the top
            * 3: Side on the left
        """
        xCenters = [amp.getBBox().getCenterX() for amp in amps]
        yCenters = [amp.getBBox().getCenterY() for amp in amps]
        xIndices = np.ceil(xCenters / np.min(xCenters) / 2).astype(int) - 1
        yIndices = np.ceil(yCenters / np.min(yCenters) / 2).astype(int) - 1
 
        nAmps = len(amps)
        ampIds = np.zeros((len(set(yIndices)), len(set(xIndices))), dtype=int)
 
        for ampId, xIndex, yIndex in zip(np.arange(nAmps), xIndices, yIndices):
            ampIds[yIndex, xIndex] = ampId
 
        ampAssociations = np.zeros((nAmps, nAmps), dtype=int)
        ampSides = np.full_like(ampAssociations, -1)
 
        for ampId in ampIds.ravel():
            neighbors, sides = self.getNeighbors(ampIds, ampId)
            interfaceWeights = (
                1
                if not self.config.applyWeights
                else np.array([self.interfaceLengthLookupBySide[side] for side in sides])
            )
            ampAssociations[ampId, neighbors] = -1 * interfaceWeights
            ampSides[ampId, neighbors] = sides
            ampAssociations[ampId, ampId] = -ampAssociations[ampId].sum()
 
        if ampAssociations.sum() != 0:
            raise RuntimeError("The `ampAssociations` array does not sum to zero.")
 
        if not np.all(ampAssociations == ampAssociations.T):
            raise RuntimeError("The `ampAssociations` is not symmetric about the diagonal.")
 
        with np.printoptions(linewidth=200):
            self.log.debug("amp associations:\n%s", ampAssociations)
            self.log.debug("amp sides:\n%s", ampSides)
 
        return ampAssociations, ampSides
 

getAmpEdges()

lsst.ip.isr.ampOffset.AmpOffsetTask.getAmpEdges	(		self,
			im,
			amps,
			ampSides )

Calculate the amp edges for all amplifiers.

Parameters
----------
im : `lsst.afw.image._image.ImageF`
    Amplifier image to extract data from.
amps : `list` [`lsst.afw.cameraGeom.Amplifier`]
    List of amplifier objects.
ampSides : `numpy.ndarray`
    An N x N matrix containing amp side information, where N is the
    number of amplifiers.

Returns
-------
ampEdges : `dict` [`int`, `dict` [`int`, `numpy.ndarray`]]
    A dictionary containing amp edge(s) for each amplifier,
    corresponding to one or more potential sides, where each edge is
    associated with a side. The outer dictionary has integer keys
    representing amplifier IDs, and the inner dictionary has integer
    keys representing side IDs for each amplifier and values that are
    1D arrays of floats representing the 1D medianified strips from the
    amp image, referred to as "amp edge":
    {ampID: {sideID: numpy.ndarray}, ...}

Definition at line 513 of file ampOffset.py.

    def getAmpEdges(self, im, amps, ampSides):
        """Calculate the amp edges for all amplifiers.
 
        Parameters
        ----------
        im : `lsst.afw.image._image.ImageF`
            Amplifier image to extract data from.
        amps : `list` [`lsst.afw.cameraGeom.Amplifier`]
            List of amplifier objects.
        ampSides : `numpy.ndarray`
            An N x N matrix containing amp side information, where N is the
            number of amplifiers.
 
        Returns
        -------
        ampEdges : `dict` [`int`, `dict` [`int`, `numpy.ndarray`]]
            A dictionary containing amp edge(s) for each amplifier,
            corresponding to one or more potential sides, where each edge is
            associated with a side. The outer dictionary has integer keys
            representing amplifier IDs, and the inner dictionary has integer
            keys representing side IDs for each amplifier and values that are
            1D arrays of floats representing the 1D medianified strips from the
            amp image, referred to as "amp edge":
            {ampID: {sideID: numpy.ndarray}, ...}
        """
        ampEdgeOuter = self.config.ampEdgeInset + self.config.ampEdgeWidth
        ampEdges = {}
        slice_map = {
            0: (slice(-ampEdgeOuter, -self.config.ampEdgeInset), slice(None)),
            1: (slice(None), slice(-ampEdgeOuter, -self.config.ampEdgeInset)),
            2: (slice(self.config.ampEdgeInset, ampEdgeOuter), slice(None)),
            3: (slice(None), slice(self.config.ampEdgeInset, ampEdgeOuter)),
        }
        for ampId, (amp, ampSides) in enumerate(zip(amps, ampSides)):
            ampEdges[ampId] = {}
            ampIm = im[amp.getBBox()].array
            # Loop over identified sides.
            for ampSide in ampSides:
                if ampSide < 0:
                    continue
                strip = ampIm[slice_map[ampSide]]
                # Catch warnings to prevent all-NaN slice RuntimeWarning.
                with warnings.catch_warnings():
                    warnings.filterwarnings("ignore", r"All-NaN (slice|axis) encountered")
                    ampEdges[ampId][ampSide] = np.nanmedian(strip, axis=ampSide % 2)  # 1D medianified strip
        return ampEdges
 

getAmpOffsets()

lsst.ip.isr.ampOffset.AmpOffsetTask.getAmpOffsets	(		self,
			im,
			amps,
			associations,
			sides )

Calculate the amp offsets for all amplifiers.

Parameters
----------
im : `lsst.afw.image._image.ImageF`
    Amplifier image to extract data from.
amps : `list` [`lsst.afw.cameraGeom.Amplifier`]
    List of amplifier objects.
associations : numpy.ndarray
    An N x N matrix containing amp association information, where N is
    the number of amplifiers.
sides : numpy.ndarray
    An N x N matrix containing amp side information, where N is the
    number of amplifiers.

Returns
-------
ampsOffsets : `numpy.ndarray`
    1D float array containing the calculated amp offsets for all
    amplifiers.
interfaceOffsetDict : `dict` [`str`, `float`]
    Dictionary mapping interface IDs to their corresponding raw
    (uncapped) offset values.

Definition at line 398 of file ampOffset.py.

    def getAmpOffsets(self, im, amps, associations, sides):
        """Calculate the amp offsets for all amplifiers.
 
        Parameters
        ----------
        im : `lsst.afw.image._image.ImageF`
            Amplifier image to extract data from.
        amps : `list` [`lsst.afw.cameraGeom.Amplifier`]
            List of amplifier objects.
        associations : numpy.ndarray
            An N x N matrix containing amp association information, where N is
            the number of amplifiers.
        sides : numpy.ndarray
            An N x N matrix containing amp side information, where N is the
            number of amplifiers.
 
        Returns
        -------
        ampsOffsets : `numpy.ndarray`
            1D float array containing the calculated amp offsets for all
            amplifiers.
        interfaceOffsetDict : `dict` [`str`, `float`]
            Dictionary mapping interface IDs to their corresponding raw
            (uncapped) offset values.
        """
        ampsOffsets = np.zeros(len(amps))
        ampsEdges = self.getAmpEdges(im, amps, sides)
        ampsNames = [amp.getName() for amp in amps]
        interfaceOffsetLookup = {}
 
        interfaceIds = []
        interfaceOffsetOriginals = []
        ampEdgeGoodFracs = []
        minFracFails = []
        maxOffsetFails = []
        for ampId, ampAssociations in enumerate(associations):
            ampNeighbors = np.ravel(np.where(ampAssociations < 0))
            for ampNeighbor in ampNeighbors:
                ampSide = sides[ampId][ampNeighbor]
                interfaceWeight = (
                    1 if not self.config.applyWeights else self.interfaceLengthLookupBySide[ampSide]
                )
                edgeA = ampsEdges[ampId][ampSide]
                edgeB = ampsEdges[ampNeighbor][(ampSide + 2) % 4]
                if ampId < ampNeighbor:
                    (
                        interfaceId,
                        interfaceOffset,
                        interfaceOffsetOriginal,
                        ampEdgeGoodFrac,
                        minFracFail,
                        maxOffsetFail,
                    ) = self.getInterfaceOffset(ampsNames[ampId], ampsNames[ampNeighbor], edgeA, edgeB)
                    interfaceIds.append(interfaceId)
                    interfaceOffsetOriginals.append(interfaceOffsetOriginal)
                    ampEdgeGoodFracs.append(ampEdgeGoodFrac)
                    minFracFails.append(minFracFail)
                    maxOffsetFails.append(maxOffsetFail)
                    interfaceOffsetLookup[f"{ampId:02d}:{ampNeighbor:02d}"] = interfaceOffset
                else:
                    interfaceOffset = -interfaceOffsetLookup[f"{ampNeighbor:02d}:{ampId:02d}"]
                ampsOffsets[ampId] += interfaceWeight * interfaceOffset
        if interfaceOffsetOriginals:
            self.log.debug(
                "Raw (uncapped) amp offset values for all interfaces: %s",
                ", ".join(
                    [
                        f"{interfaceId}={interfaceOffset:0.2f}"
                        for interfaceId, interfaceOffset in zip(interfaceIds, interfaceOffsetOriginals)
                    ]
                ),
            )
            quartile_summary = np.nanpercentile(interfaceOffsetOriginals, [0, 25, 50, 75, 100])
            self.log.info(
                "Raw amp offset quartile summary for all interfaces (min, Q1, Q2, Q3, max): "
                "%.4f, %.4f, %.4f, %.4f, %.4f",
                *quartile_summary,
            )
        log_fn = self.log.warning if self.config.doApplyAmpOffset else self.log.info
        if any(minFracFails):
            log_fn(
                "The fraction of unmasked edge pixels for the following amp interfaces is below the "
                "configured threshold (%s): %s",
                self.config.ampEdgeMinFrac,
                ", ".join(
                    [
                        f"{interfaceId} ({ampEdgeGoodFrac:0.2f})"
                        for interfaceId, ampEdgeGoodFrac, minFracFail in zip(
                            interfaceIds, ampEdgeGoodFracs, minFracFails
                        )
                        if minFracFail
                    ]
                ),
            )
        if any(maxOffsetFails):
            log_fn(
                "Absolute amp offsets exceed the configured maximum (%s) and have been set to zero for the "
                "following amp interfaces: %s",
                self.config.ampEdgeMaxOffset,
                ", ".join(
                    [
                        f"{interfaceId}={np.abs(interfaceOffset):0.2f}"
                        for interfaceId, interfaceOffset, maxOffsetFail in zip(
                            interfaceIds, interfaceOffsetOriginals, maxOffsetFails
                        )
                        if maxOffsetFail
                    ]
                ),
            )
 
        # Pair each interface ID with its corresponding original offset.
        interfaceOffsetDict = dict(zip(interfaceIds, interfaceOffsetOriginals))
 
        return ampsOffsets, interfaceOffsetDict
 

getInterfaceOffset()

lsst.ip.isr.ampOffset.AmpOffsetTask.getInterfaceOffset	(		self,
			ampNameA,
			ampNameB,
			edgeA,
			edgeB )

Calculate the amp offset for a given interface between two
amplifiers.

Parameters
----------
ampNameA : str
    Name of the first amplifier.
ampNameB : str
    Name of the second amplifier.
edgeA : numpy.ndarray
    Amp edge for the first amplifier.
edgeB : numpy.ndarray
    Amp edge for the second amplifier.

Returns
-------
interfaceOffset : float
    The calculated amp offset value for the given interface between
    amps A and B.
interfaceOffsetOriginal : float
    The original calculated amp offset value for the given interface
    between amps A and B.
ampEdgeGoodFrac : float
    Fraction of viable pixel rows along the amp edge.
minFracFail : bool
    True if the fraction of unmasked pixel rows is below the
    ampEdgeMinFrac threshold.
maxOffsetFail : bool
    True if the absolute offset value exceeds the ampEdgeMaxOffset
    threshold.

Definition at line 560 of file ampOffset.py.

    def getInterfaceOffset(self, ampNameA, ampNameB, edgeA, edgeB):
        """Calculate the amp offset for a given interface between two
        amplifiers.
 
        Parameters
        ----------
        ampNameA : str
            Name of the first amplifier.
        ampNameB : str
            Name of the second amplifier.
        edgeA : numpy.ndarray
            Amp edge for the first amplifier.
        edgeB : numpy.ndarray
            Amp edge for the second amplifier.
 
        Returns
        -------
        interfaceOffset : float
            The calculated amp offset value for the given interface between
            amps A and B.
        interfaceOffsetOriginal : float
            The original calculated amp offset value for the given interface
            between amps A and B.
        ampEdgeGoodFrac : float
            Fraction of viable pixel rows along the amp edge.
        minFracFail : bool
            True if the fraction of unmasked pixel rows is below the
            ampEdgeMinFrac threshold.
        maxOffsetFail : bool
            True if the absolute offset value exceeds the ampEdgeMaxOffset
            threshold.
        """
        interfaceId = f"{ampNameA}-{ampNameB}"
        sctrl = StatisticsControl()
        # NOTE: Taking the difference with the order below fixes the sign flip
        # in the B matrix.
        edgeDiff = edgeA - edgeB
        if self.config.doWindowSmoothing:
            # Compute rolling averages.
            window = int(self.config.ampEdgeWindowFrac * len(edgeDiff))
            edgeDiffSum = np.convolve(np.nan_to_num(edgeDiff), np.ones(window), "same")
            edgeDiffNum = np.convolve(~np.isnan(edgeDiff), np.ones(window), "same")
            edgeDiffAvg = edgeDiffSum / np.clip(edgeDiffNum, 1, None)
        else:
            # Directly use the difference.
            edgeDiffAvg = edgeDiff.copy()
        edgeDiffAvg[np.isnan(edgeDiff)] = np.nan
        # Take clipped mean of rolling average data as amp offset value.
        interfaceOffset = makeStatistics(edgeDiffAvg, MEANCLIP, sctrl).getValue()
        interfaceOffsetOriginal = interfaceOffset
        ampEdgeGoodFrac = 1 - (np.sum(np.isnan(edgeDiffAvg)) / len(edgeDiffAvg))
 
        # Perform a couple of do-no-harm safety checks:
        # a) The fraction of unmasked pixel rows is > ampEdgeMinFrac,
        # b) The absolute offset ADU value is < ampEdgeMaxOffset.
        minFracFail = ampEdgeGoodFrac < self.config.ampEdgeMinFrac
        maxOffsetFail = np.abs(interfaceOffset) > self.config.ampEdgeMaxOffset
        if minFracFail or maxOffsetFail:
            interfaceOffset = 0
        self.log.debug(
            f"amp interface '{interfaceId}': "
            f"viable edge difference frac = {ampEdgeGoodFrac:.2f}, "
            f"amp offset = {interfaceOffsetOriginal:.3f}"
        )
        return (
            interfaceId,
            interfaceOffset,
            interfaceOffsetOriginal,
            ampEdgeGoodFrac,
            minFracFail,
            maxOffsetFail,
        )

getNeighbors()

lsst.ip.isr.ampOffset.AmpOffsetTask.getNeighbors	(		self,
			ampIds,
			ampId )

Get the neighbor amplifiers and their sides for a given
amplifier.

Parameters
----------
ampIds : `numpy.ndarray`
    Matrix with amp side association information.
ampId : `int`
    The amplifier ID for which neighbor amplifiers and side IDs
    are to be found.

Returns
-------
neighbors : `list` [`int`]
    List of neighbor amplifier IDs.
sides : `list` [`int`]
    List of side IDs, with each ID corresponding to its respective
    neighbor amplifier.

Definition at line 363 of file ampOffset.py.

    def getNeighbors(self, ampIds, ampId):
        """Get the neighbor amplifiers and their sides for a given
        amplifier.
 
        Parameters
        ----------
        ampIds : `numpy.ndarray`
            Matrix with amp side association information.
        ampId : `int`
            The amplifier ID for which neighbor amplifiers and side IDs
            are to be found.
 
        Returns
        -------
        neighbors : `list` [`int`]
            List of neighbor amplifier IDs.
        sides : `list` [`int`]
            List of side IDs, with each ID corresponding to its respective
            neighbor amplifier.
        """
        m, n = ampIds.shape
        r, c = np.ravel(np.where(ampIds == ampId))
        neighbors, sides = [], []
        sideLookup = {
            0: (r + 1, c),
            1: (r, c + 1),
            2: (r - 1, c),
            3: (r, c - 1),
        }
        for side, (row, column) in sideLookup.items():
            if 0 <= row < m and 0 <= column < n:
                neighbors.append(ampIds[row][column])
                sides.append(side)
        return neighbors, sides
 

run()

lsst.ip.isr.ampOffset.AmpOffsetTask.run	(		self,
			exposure )

Calculate amp offset values, determine corrective pedestals for each
amp, and update the input exposure in-place.

Parameters
----------
exposure: `lsst.afw.image.Exposure`
    Exposure to be corrected for amp offsets.

Definition at line 146 of file ampOffset.py.

    def run(self, exposure):
        """Calculate amp offset values, determine corrective pedestals for each
        amp, and update the input exposure in-place.
 
        Parameters
        ----------
        exposure: `lsst.afw.image.Exposure`
            Exposure to be corrected for amp offsets.
        """
 
        # Generate an exposure clone to work on and establish the bit mask.
        exp = exposure.clone()
        bitMask = exp.mask.getPlaneBitMask(self.background.config.ignoredPixelMask)
        amps = exp.getDetector().getAmplifiers()
 
        # Check that all amps have the same gemotry.
        ampDims = [amp.getBBox().getDimensions() for amp in amps]
        if not all(dim == ampDims[0] for dim in ampDims):
            raise RuntimeError("All amps should have the same geometry.")
        else:
            # The zeroth amp is representative of all amps in the detector.
            self.ampDims = ampDims[0]
            # Dictionary mapping side numbers to interface lengths.
            # See `getAmpAssociations()` for details about sides.
            self.interfaceLengthLookupBySide = {i: self.ampDims[i % 2] for i in range(4)}
 
        # Determine amplifier geometry.
        ampWidths = {amp.getBBox().getWidth() for amp in amps}
        ampHeights = {amp.getBBox().getHeight() for amp in amps}
        if len(ampWidths) > 1 or len(ampHeights) > 1:
            raise NotImplementedError(
                "Amp offset correction is not yet implemented for detectors with differing amp sizes."
            )
 
        # Assuming all the amps have the same geometry.
        self.shortAmpSide = np.min(ampDims[0])
 
        # Check that the edge width and inset are not too large.
        if self.config.ampEdgeWidth >= self.shortAmpSide - 2 * self.config.ampEdgeInset:
            raise RuntimeError(
                f"The edge width ({self.config.ampEdgeWidth}) plus insets ({self.config.ampEdgeInset}) "
                f"exceed the amp's short side ({self.shortAmpSide}). This setup leads to incorrect results."
            )
 
        # Fit and subtract background.
        if self.config.doBackground:
            maskedImage = exp.getMaskedImage()
            # Assuming all the detectors are the same.
            nX = exp.getWidth() // (self.shortAmpSide * self.config.backgroundFractionSample) + 1
            nY = exp.getHeight() // (self.shortAmpSide * self.config.backgroundFractionSample) + 1
            # This ensures that the `binSize` is as large as possible,
            # preventing background subtraction from inadvertently removing the
            # amp offset signature. Here it's set to the shorter dimension of
            # the amplifier by default (`backgroundFractionSample` = 1), which
            # seems reasonable.
            bg = self.background.fitBackground(maskedImage, nx=int(nX), ny=int(nY))
            bgImage = bg.getImageF(self.background.config.algorithm, self.background.config.undersampleStyle)
            maskedImage -= bgImage
 
        # Detect sources and update cloned exposure mask planes in-place.
        if self.config.doDetection:
            schema = SourceTable.makeMinimalSchema()
            table = SourceTable.make(schema)
            # Detection sigma, used for smoothing and to grow detections, is
            # normally measured from the PSF of the exposure. As the PSF hasn't
            # been measured at this stage of processing, sigma is instead
            # set to an approximate value here (which should be sufficient).
            _ = self.detection.run(table=table, exposure=exp, sigma=2)
 
        # Safety check: do any pixels remain for amp offset estimation?
        if (exp.mask.array & bitMask).all():
            log_fn = self.log.warning if self.config.doApplyAmpOffset else self.log.info
            log_fn(
                "All pixels masked: cannot calculate any amp offset corrections. "
                "All pedestals are being set to zero."
            )
            pedestals = np.zeros(len(amps))
        else:
            # Set up amp offset inputs.
            im = exp.image
            im.array[(exp.mask.array & bitMask) > 0] = np.nan
 
            if self.config.ampEdgeWindowFrac > 1:
                raise RuntimeError(
                    f"The specified fraction (`ampEdgeWindowFrac`={self.config.ampEdgeWindowFrac}) of the "
                    "edge length exceeds 1. This leads to complications downstream, after convolution in "
                    "the `getInterfaceOffset()` method. Please modify the `ampEdgeWindowFrac` value in the "
                    "config to be 1 or less and rerun."
                )
 
            # Obtain association and offset matrices.
            A, sides = self.getAmpAssociations(amps)
            B, interfaceOffsetDict = self.getAmpOffsets(im, amps, A, sides)
 
            # If least-squares minimization fails, convert NaNs to zeroes,
            # ensuring that no values are erroneously added/subtracted.
            pedestals = np.nan_to_num(np.linalg.lstsq(A, B, rcond=None)[0])
 
        metadata = exposure.getMetadata()  # Exposure metadata.
        self.metadata["AMPOFFSET_PEDESTALS"] = {}  # Task metadata.
        ampNames = [amp.getName() for amp in amps]
 
        # Add the amp interface offsets to the exposure metadata.
        for interfaceId, interfaceOffset in interfaceOffsetDict.items():
            metadata.set(
                f"LSST ISR AMPOFFSET INTERFACEOFFSET {interfaceId}",
                float(interfaceOffset),
                f"Raw amp interface offset calculated for {interfaceId}",
            )
 
        for ampName, amp, pedestal in zip(ampNames, amps, pedestals):
            # Add the amp pedestal to the exposure metadata.
            metadata.set(
                f"LSST ISR AMPOFFSET PEDESTAL {ampName}",
                float(pedestal),
                f"Pedestal level calculated for amp {ampName}",
            )
            if self.config.doApplyAmpOffset:
                ampIm = exposure.image[amp.getBBox()].array
                ampIm -= pedestal
            # Add the amp pedestal to the "Task" metadata as well.
            # Needed for Sasquatch/Chronograf!
            self.metadata["AMPOFFSET_PEDESTALS"][ampName] = float(pedestal)
        if self.config.doApplyAmpOffset:
            status = "subtracted from exposure"
            metadata.set("LSST ISR AMPOFFSET PEDESTAL SUBTRACTED", True, "Amp pedestals have been subtracted")
        else:
            status = "not subtracted from exposure"
            metadata.set(
                "LSST ISR AMPOFFSET PEDESTAL SUBTRACTED", False, "Amp pedestals have not been subtracted"
            )
        ampPedestalReport = ", ".join(
            [f"{ampName}: {ampPedestal:.4f}" for (ampName, ampPedestal) in zip(ampNames, pedestals)]
        )
        self.log.info(f"Amp pedestal values ({status}): {ampPedestalReport}")
 
        return Struct(pedestals=pedestals)
 

Member Data Documentation

_DefaultName

str lsst.ip.isr.ampOffset.AmpOffsetTask._DefaultName = "isrAmpOffset"

staticprotected

Definition at line 134 of file ampOffset.py.

ampDims

lsst.ip.isr.ampOffset.AmpOffsetTask.ampDims = ampDims[0]

Definition at line 167 of file ampOffset.py.

ConfigClass

lsst.ip.isr.ampOffset.AmpOffsetTask.ConfigClass = AmpOffsetConfig

static

Definition at line 133 of file ampOffset.py.

interfaceLengthLookupBySide

dict lsst.ip.isr.ampOffset.AmpOffsetTask.interfaceLengthLookupBySide = {i: self.ampDims[i % 2] for i in range(4)}

Definition at line 170 of file ampOffset.py.

shortAmpSide

int lsst.ip.isr.ampOffset.AmpOffsetTask.shortAmpSide = 0

Definition at line 144 of file ampOffset.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/g9f1445be69+9c28a42a87/python/lsst/ip/isr/ampOffset.py