Inheritance diagram for lsst.ip.isr.linearize.Linearizer:

Public Member Functions
	__init__ (self, table=None, **kwargs)

	updateMetadata (self, setDate=False, **kwargs)

	fromDetector (self, detector)

	fromDict (cls, dictionary)

	toDict (self)

	fromTable (cls, tableList)

	toTable (self)

	getLinearityTypeByName (self, linearityTypeName)

	validate (self, detector=None, amplifier=None)

	applyLinearity (self, image, detector=None, log=None, gains=None)

Public Attributes
	hasLinearity

	override

	ampNames

	linearityCoeffs

	linearityType

	linearityBBox

	fitParams

	fitParamsErr

	fitChiSq

	fitResiduals

	fitResidualsSigmaMad

	linearFit

	linearityTurnoff

	linearityMaxSignal

	tableData

	linearityUnits

	log

Protected Attributes
	_detectorName

	_detectorSerial

	_detectorId

Static Protected Attributes
str	_OBSTYPE = "LINEARIZER"

str	_SCHEMA = 'Gen3 Linearizer'

float	_VERSION = 1.4

Detailed Description

Parameter set for linearization.

These parameters are included in `lsst.afw.cameraGeom.Amplifier`, but
should be accessible externally to allow for testing.

Parameters
----------
table : `numpy.array`, optional
    Lookup table; a 2-dimensional array of floats:

    - one row for each row index (value of coef[0] in the amplifier)
    - one column for each image value

    To avoid copying the table the last index should vary fastest
    (numpy default "C" order)
detector : `lsst.afw.cameraGeom.Detector`, optional
    Detector object.  Passed to self.fromDetector() on init.
log : `logging.Logger`, optional
    Logger to handle messages.
kwargs : `dict`, optional
    Other keyword arguments to pass to the parent init.

Raises
------
RuntimeError
    Raised if the supplied table is not 2D, or if the table has fewer
    columns than rows (indicating that the indices are swapped).

Notes
-----
The linearizer attributes stored are:

hasLinearity : `bool`
    Whether a linearity correction is defined for this detector.
override : `bool`
    Whether the detector parameters should be overridden.
ampNames : `list` [`str`]
    List of amplifier names to correct.
linearityCoeffs : `dict` [`str`, `numpy.array`]
    Coefficients to use in correction.  Indexed by amplifier
    names.  The format of the array depends on the type of
    correction to apply.
linearityType : `dict` [`str`, `str`]
    Type of correction to use, indexed by amplifier names.
linearityBBox : `dict` [`str`, `lsst.geom.Box2I`]
    Bounding box the correction is valid over, indexed by
    amplifier names.
fitParams : `dict` [`str`, `numpy.array`], optional
    Linearity fit parameters used to construct the correction
    coefficients, indexed as above.
fitParamsErr : `dict` [`str`, `numpy.array`], optional
    Uncertainty values of the linearity fit parameters used to
    construct the correction coefficients, indexed as above.
fitChiSq : `dict` [`str`, `float`], optional
    Chi-squared value of the linearity fit, indexed as above.
fitResiduals : `dict` [`str`, `numpy.array`], optional
    Residuals of the fit, indexed as above. Used for
    calculating photdiode corrections
fitResidualsSigmaMad : `dict` [`str`, `float`], optional
    Robust median-absolute-deviation of fit residuals, scaled
    by the signal level.
linearFit : The linear fit to the low flux region of the curve.
    [intercept, slope].
tableData : `numpy.array`, optional
    Lookup table data for the linearity correction.

Version 1.4 adds ``linearityTurnoff`` and ``linearityMaxSignal``.

Definition at line 40 of file linearize.py.

Constructor & Destructor Documentation

◆ init()

lsst.ip.isr.linearize.Linearizer.__init__	(		self,
			table = None,
		**	kwargs )

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 113 of file linearize.py.

    def __init__(self, table=None, **kwargs):
        self.hasLinearity = False
        self.override = False
 
        self.ampNames = list()
        self.linearityCoeffs = dict()
        self.linearityType = dict()
        self.linearityBBox = dict()
        self.fitParams = dict()
        self.fitParamsErr = dict()
        self.fitChiSq = dict()
        self.fitResiduals = dict()
        self.fitResidualsSigmaMad = dict()
        self.linearFit = dict()
        self.linearityTurnoff = dict()
        self.linearityMaxSignal = dict()
        self.tableData = None
        if table is not None:
            if len(table.shape) != 2:
                raise RuntimeError("table shape = %s; must have two dimensions" % (table.shape,))
            if table.shape[1] < table.shape[0]:
                raise RuntimeError("table shape = %s; indices are switched" % (table.shape,))
            self.tableData = np.array(table, order="C")
 
        # The linearizer is always natively in adu because it
        # is computed prior to computing gains.
        self.linearityUnits = 'adu'
 
        super().__init__(**kwargs)
        self.requiredAttributes.update(['hasLinearity', 'override',
                                        'ampNames',
                                        'linearityCoeffs', 'linearityType', 'linearityBBox',
                                        'fitParams', 'fitParamsErr', 'fitChiSq',
                                        'fitResiduals', 'fitResidualsSigmaMad', 'linearFit', 'tableData',
                                        'units', 'linearityTurnoff', 'linearityMaxSignal'])
 

Member Function Documentation

◆ applyLinearity()

lsst.ip.isr.linearize.Linearizer.applyLinearity	(	self,
		image,
		detector = None,
		log = None,
		gains = None )

Apply the linearity to an image.

If the linearity parameters are populated, use those,
otherwise use the values from the detector.

Parameters
----------
image : `~lsst.afw.image.image`
    Image to correct.
detector : `~lsst.afw.cameraGeom.detector`, optional
    Detector to use to determine exposure trimmed state.  If
    supplied, but no other linearity information is provided
    by the calibration, then the static solution stored in the
    detector will be used.
log : `~logging.Logger`, optional
    Log object to use for logging.
gains : `dict` [`str`, `float`], optional
    Dictionary of amp name to gain. If this is provided then
    linearity terms will be converted from adu to electrons.
    Only used for Spline linearity corrections.

Definition at line 497 of file linearize.py.

    def applyLinearity(self, image, detector=None, log=None, gains=None):
        """Apply the linearity to an image.
 
        If the linearity parameters are populated, use those,
        otherwise use the values from the detector.
 
        Parameters
        ----------
        image : `~lsst.afw.image.image`
            Image to correct.
        detector : `~lsst.afw.cameraGeom.detector`, optional
            Detector to use to determine exposure trimmed state.  If
            supplied, but no other linearity information is provided
            by the calibration, then the static solution stored in the
            detector will be used.
        log : `~logging.Logger`, optional
            Log object to use for logging.
        gains : `dict` [`str`, `float`], optional
            Dictionary of amp name to gain. If this is provided then
            linearity terms will be converted from adu to electrons.
            Only used for Spline linearity corrections.
        """
        if log is None:
            log = self.log
        if detector and not self.hasLinearity:
            self.fromDetector(detector)
 
        self.validate(detector)
 
        # Check if the image is trimmed.
        isTrimmed = None
        if detector:
            isTrimmed = isTrimmedImage(image, detector)
 
        numAmps = 0
        numLinearized = 0
        numOutOfRange = 0
        for ampName in self.linearityType.keys():
            linearizer = self.getLinearityTypeByName(self.linearityType[ampName])
            numAmps += 1
 
            if gains and self.linearityUnits == 'adu':
                gainValue = gains[ampName]
            else:
                gainValue = 1.0
 
            if linearizer is not None:
                match isTrimmed:
                    case True:
                        bbox = detector[ampName].getBBox()
                    case False:
                        bbox = detector[ampName].getRawBBox()
                    case None:
                        bbox = self.linearityBBox[ampName]
 
                ampView = image.Factory(image, bbox)
                success, outOfRange = linearizer()(ampView, **{'coeffs': self.linearityCoeffs[ampName],
                                                               'table': self.tableData,
                                                               'log': self.log,
                                                               'gain': gainValue})
                numOutOfRange += outOfRange
                if success:
                    numLinearized += 1
                elif log is not None:
                    log.warning("Amplifier %s did not linearize.",
                                ampName)
        return Struct(
            numAmps=numAmps,
            numLinearized=numLinearized,
            numOutOfRange=numOutOfRange
        )
 
 

◆ fromDetector()

lsst.ip.isr.linearize.Linearizer.fromDetector	(		self,
			detector )

Read linearity parameters from a detector.

Parameters
----------
detector : `lsst.afw.cameraGeom.detector`
    Input detector with parameters to use.

Returns
-------
calib : `lsst.ip.isr.Linearizer`
    The calibration constructed from the detector.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 170 of file linearize.py.

    def fromDetector(self, detector):
        """Read linearity parameters from a detector.
 
        Parameters
        ----------
        detector : `lsst.afw.cameraGeom.detector`
            Input detector with parameters to use.
 
        Returns
        -------
        calib : `lsst.ip.isr.Linearizer`
            The calibration constructed from the detector.
        """
        self._detectorName = detector.getName()
        self._detectorSerial = detector.getSerial()
        self._detectorId = detector.getId()
        self.hasLinearity = True
 
        # Do not translate Threshold, Maximum, Units.
        for amp in detector.getAmplifiers():
            ampName = amp.getName()
            self.ampNames.append(ampName)
            self.linearityType[ampName] = amp.getLinearityType()
            self.linearityCoeffs[ampName] = amp.getLinearityCoeffs()
            self.linearityBBox[ampName] = amp.getBBox()
 
        # Detector linearizers (legacy) are assumed to be adu units.
        self.linearityUnits = 'adu'
 
        return self
 

◆ fromDict()

lsst.ip.isr.linearize.Linearizer.fromDict	(		cls,
			dictionary )

Construct a calibration from a dictionary of properties

Parameters
----------
dictionary : `dict`
    Dictionary of properties

Returns
-------
calib : `lsst.ip.isr.Linearity`
    Constructed calibration.

Raises
------
RuntimeError
    Raised if the supplied dictionary is for a different
    calibration.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 202 of file linearize.py.

    def fromDict(cls, dictionary):
        """Construct a calibration from a dictionary of properties
 
        Parameters
        ----------
        dictionary : `dict`
            Dictionary of properties
 
        Returns
        -------
        calib : `lsst.ip.isr.Linearity`
            Constructed calibration.
 
        Raises
        ------
        RuntimeError
            Raised if the supplied dictionary is for a different
            calibration.
        """
 
        calib = cls()
 
        if calib._OBSTYPE != dictionary['metadata']['OBSTYPE']:
            raise RuntimeError(f"Incorrect linearity supplied.  Expected {calib._OBSTYPE}, "
                               f"found {dictionary['metadata']['OBSTYPE']}")
 
        calib.setMetadata(dictionary['metadata'])
 
        calib.hasLinearity = dictionary.get('hasLinearity',
                                            dictionary['metadata'].get('HAS_LINEARITY', False))
        calib.override = dictionary.get('override', True)
 
        # Old linearizers which do not have linearityUnits are
        # assumed to be adu because that's all that has been
        # supported.
        calib.linearityUnits = dictionary.get('linearityUnits', 'adu')
 
        if calib.hasLinearity:
            for ampName in dictionary['amplifiers']:
                amp = dictionary['amplifiers'][ampName]
                calib.ampNames.append(ampName)
                calib.linearityCoeffs[ampName] = np.array(amp.get('linearityCoeffs', [0.0]))
                calib.linearityType[ampName] = amp.get('linearityType', 'None')
                calib.linearityBBox[ampName] = amp.get('linearityBBox', None)
 
                calib.fitParams[ampName] = np.array(amp.get('fitParams', [0.0]))
                calib.fitParamsErr[ampName] = np.array(amp.get('fitParamsErr', [0.0]))
                calib.fitChiSq[ampName] = amp.get('fitChiSq', np.nan)
                calib.fitResiduals[ampName] = np.array(amp.get('fitResiduals', [0.0]))
                calib.fitResidualsSigmaMad[ampName] = np.array(amp.get('fitResidualsSigmaMad', np.nan))
                calib.linearFit[ampName] = np.array(amp.get('linearFit', [0.0]))
 
                calib.linearityTurnoff[ampName] = np.array(amp.get('linearityTurnoff', np.nan))
                calib.linearityMaxSignal[ampName] = np.array(amp.get('linearityMaxSignal', np.nan))
 
            calib.tableData = dictionary.get('tableData', None)
            if calib.tableData:
                calib.tableData = np.array(calib.tableData)
 
        return calib
 

◆ fromTable()

lsst.ip.isr.linearize.Linearizer.fromTable	(		cls,
			tableList )

Read linearity from a FITS file.

This method uses the `fromDict` method to create the
calibration, after constructing an appropriate dictionary from
the input tables.

Parameters
----------
tableList : `list` [`astropy.table.Table`]
    afwTable read from input file name.

Returns
-------
linearity : `~lsst.ip.isr.linearize.Linearizer``
    Linearity parameters.

Notes
-----
The method reads a FITS file with 1 or 2 extensions. The metadata is
read from the header of extension 1, which must exist.  Then the table
is loaded, and  the ['AMPLIFIER_NAME', 'TYPE', 'COEFFS', 'BBOX_X0',
'BBOX_Y0', 'BBOX_DX', 'BBOX_DY'] columns are read and used to set each
dictionary by looping over rows.
Extension 2 is then attempted to read in the try block (which only
exists for lookup tables). It has a column named 'LOOKUP_VALUES' that
contains a vector of the lookup entries in each row.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 300 of file linearize.py.

    def fromTable(cls, tableList):
        """Read linearity from a FITS file.
 
        This method uses the `fromDict` method to create the
        calibration, after constructing an appropriate dictionary from
        the input tables.
 
        Parameters
        ----------
        tableList : `list` [`astropy.table.Table`]
            afwTable read from input file name.
 
        Returns
        -------
        linearity : `~lsst.ip.isr.linearize.Linearizer``
            Linearity parameters.
 
        Notes
        -----
        The method reads a FITS file with 1 or 2 extensions. The metadata is
        read from the header of extension 1, which must exist.  Then the table
        is loaded, and  the ['AMPLIFIER_NAME', 'TYPE', 'COEFFS', 'BBOX_X0',
        'BBOX_Y0', 'BBOX_DX', 'BBOX_DY'] columns are read and used to set each
        dictionary by looping over rows.
        Extension 2 is then attempted to read in the try block (which only
        exists for lookup tables). It has a column named 'LOOKUP_VALUES' that
        contains a vector of the lookup entries in each row.
        """
        coeffTable = tableList[0]
 
        metadata = coeffTable.meta
        inDict = dict()
        inDict['metadata'] = metadata
        inDict['hasLinearity'] = metadata.get('HAS_LINEARITY', False)
        inDict['amplifiers'] = dict()
        inDict['linearityUnits'] = metadata.get('LINEARITY_UNITS', 'adu')
 
        for record in coeffTable:
            ampName = record['AMPLIFIER_NAME']
 
            fitParams = record['FIT_PARAMS'] if 'FIT_PARAMS' in record.columns else np.array([0.0])
            fitParamsErr = record['FIT_PARAMS_ERR'] if 'FIT_PARAMS_ERR' in record.columns else np.array([0.0])
            fitChiSq = record['RED_CHI_SQ'] if 'RED_CHI_SQ' in record.columns else np.nan
            fitResiduals = record['FIT_RES'] if 'FIT_RES' in record.columns else np.array([0.0])
            fitResidualsSigmaMad = record['FIT_RES_SIGMAD'] if 'FIT_RES_SIGMAD' in record.columns else np.nan
            linearFit = record['LIN_FIT'] if 'LIN_FIT' in record.columns else np.array([0.0])
 
            linearityTurnoff = record['LINEARITY_TURNOFF'] if 'LINEARITY_TURNOFF' in record.columns \
                else np.nan
            linearityMaxSignal = record['LINEARITY_MAX_SIGNAL'] if 'LINEARITY_MAX_SIGNAL' in record.columns \
                else np.nan
 
            inDict['amplifiers'][ampName] = {
                'linearityType': record['TYPE'],
                'linearityCoeffs': record['COEFFS'],
                'linearityBBox': Box2I(Point2I(record['BBOX_X0'], record['BBOX_Y0']),
                                       Extent2I(record['BBOX_DX'], record['BBOX_DY'])),
                'fitParams': fitParams,
                'fitParamsErr': fitParamsErr,
                'fitChiSq': fitChiSq,
                'fitResiduals': fitResiduals,
                'fitResidualsSigmaMad': fitResidualsSigmaMad,
                'linearFit': linearFit,
                'linearityTurnoff': linearityTurnoff,
                'linearityMaxSignal': linearityMaxSignal,
            }
 
        if len(tableList) > 1:
            tableData = tableList[1]
            inDict['tableData'] = [record['LOOKUP_VALUES'] for record in tableData]
 
        return cls().fromDict(inDict)
 

◆ getLinearityTypeByName()

lsst.ip.isr.linearize.Linearizer.getLinearityTypeByName	(		self,
			linearityTypeName )

Determine the linearity class to use from the type name.

Parameters
----------
linearityTypeName : str
    String name of the linearity type that is needed.

Returns
-------
linearityType : `~lsst.ip.isr.linearize.LinearizeBase`
    The appropriate linearity class to use.  If no matching class
    is found, `None` is returned.

Definition at line 413 of file linearize.py.

    def getLinearityTypeByName(self, linearityTypeName):
        """Determine the linearity class to use from the type name.
 
        Parameters
        ----------
        linearityTypeName : str
            String name of the linearity type that is needed.
 
        Returns
        -------
        linearityType : `~lsst.ip.isr.linearize.LinearizeBase`
            The appropriate linearity class to use.  If no matching class
            is found, `None` is returned.
        """
        for t in [LinearizeLookupTable,
                  LinearizeSquared,
                  LinearizePolynomial,
                  LinearizeProportional,
                  LinearizeSpline,
                  LinearizeNone]:
            if t.LinearityType == linearityTypeName:
                return t
        return None
 

◆ toDict()

lsst.ip.isr.linearize.Linearizer.toDict ( self )

Return linearity parameters as a dict.

Returns
-------
outDict : `dict`:

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 263 of file linearize.py.

    def toDict(self):
        """Return linearity parameters as a dict.
 
        Returns
        -------
        outDict : `dict`:
        """
        self.updateMetadata()
 
        outDict = {'metadata': self.getMetadata(),
                   'detectorName': self._detectorName,
                   'detectorSerial': self._detectorSerial,
                   'detectorId': self._detectorId,
                   'hasTable': self.tableData is not None,
                   'amplifiers': dict(),
                   'linearityUnits': self.linearityUnits,
                   }
        for ampName in self.linearityType:
            outDict['amplifiers'][ampName] = {
                'linearityType': self.linearityType[ampName],
                'linearityCoeffs': self.linearityCoeffs[ampName].tolist(),
                'linearityBBox': self.linearityBBox[ampName],
                'fitParams': self.fitParams[ampName].tolist(),
                'fitParamsErr': self.fitParamsErr[ampName].tolist(),
                'fitChiSq': self.fitChiSq[ampName],
                'fitResiduals': self.fitResiduals[ampName].tolist(),
                'fitResidualsSigmaMad': self.fitResiduals[ampName],
                'linearFit': self.linearFit[ampName].tolist(),
                'linearityTurnoff': self.linearityTurnoff[ampName],
                'linearityMaxSignal': self.linearityMaxSignal[ampName],
            }
        if self.tableData is not None:
            outDict['tableData'] = self.tableData.tolist()
 
        return outDict
 

◆ toTable()

lsst.ip.isr.linearize.Linearizer.toTable ( self )

Construct a list of tables containing the information in this
calibration.

The list of tables should create an identical calibration
after being passed to this class's fromTable method.

Returns
-------
tableList : `list` [`astropy.table.Table`]
    List of tables containing the linearity calibration
    information.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 373 of file linearize.py.

    def toTable(self):
        """Construct a list of tables containing the information in this
        calibration.
 
        The list of tables should create an identical calibration
        after being passed to this class's fromTable method.
 
        Returns
        -------
        tableList : `list` [`astropy.table.Table`]
            List of tables containing the linearity calibration
            information.
        """
 
        tableList = []
        self.updateMetadata()
        catalog = Table([{'AMPLIFIER_NAME': ampName,
                          'TYPE': self.linearityType[ampName],
                          'COEFFS': self.linearityCoeffs[ampName],
                          'BBOX_X0': self.linearityBBox[ampName].getMinX(),
                          'BBOX_Y0': self.linearityBBox[ampName].getMinY(),
                          'BBOX_DX': self.linearityBBox[ampName].getWidth(),
                          'BBOX_DY': self.linearityBBox[ampName].getHeight(),
                          'FIT_PARAMS': self.fitParams[ampName],
                          'FIT_PARAMS_ERR': self.fitParamsErr[ampName],
                          'RED_CHI_SQ': self.fitChiSq[ampName],
                          'FIT_RES': self.fitResiduals[ampName],
                          'FIT_RES_SIGMAD': self.fitResidualsSigmaMad[ampName],
                          'LIN_FIT': self.linearFit[ampName],
                          'LINEARITY_TURNOFF': self.linearityTurnoff[ampName],
                          'LINEARITY_MAX_SIGNAL': self.linearityMaxSignal[ampName],
                          } for ampName in self.ampNames])
        catalog.meta = self.getMetadata().toDict()
        tableList.append(catalog)
 
        if self.tableData is not None:
            catalog = Table([{'LOOKUP_VALUES': value} for value in self.tableData])
            tableList.append(catalog)
        return tableList
 

◆ updateMetadata()

lsst.ip.isr.linearize.Linearizer.updateMetadata	(		self,
			setDate = False,
		**	kwargs )

Update metadata keywords with new values.

This calls the base class's method after ensuring the required
calibration keywords will be saved.

Parameters
----------
setDate : `bool`, optional
    Update the CALIBDATE fields in the metadata to the current
    time. Defaults to False.
kwargs :
    Other keyword parameters to set in the metadata.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 149 of file linearize.py.

    def updateMetadata(self, setDate=False, **kwargs):
        """Update metadata keywords with new values.
 
        This calls the base class's method after ensuring the required
        calibration keywords will be saved.
 
        Parameters
        ----------
        setDate : `bool`, optional
            Update the CALIBDATE fields in the metadata to the current
            time. Defaults to False.
        kwargs :
            Other keyword parameters to set in the metadata.
        """
        kwargs['HAS_LINEARITY'] = self.hasLinearity
        kwargs['OVERRIDE'] = self.override
        kwargs['HAS_TABLE'] = self.tableData is not None
        kwargs['LINEARITY_UNITS'] = self.linearityUnits
 
        super().updateMetadata(setDate=setDate, **kwargs)
 

◆ validate()

lsst.ip.isr.linearize.Linearizer.validate	(	self,
		detector = None,
		amplifier = None )

Validate linearity for a detector/amplifier.

Parameters
----------
detector : `lsst.afw.cameraGeom.Detector`, optional
    Detector to validate, along with its amplifiers.
amplifier : `lsst.afw.cameraGeom.Amplifier`, optional
    Single amplifier to validate.

Raises
------
RuntimeError
    Raised if there is a mismatch in linearity parameters, and
    the cameraGeom parameters are not being overridden.

Reimplemented from lsst.ip.isr.calibType.IsrCalib.

Definition at line 437 of file linearize.py.

    def validate(self, detector=None, amplifier=None):
        """Validate linearity for a detector/amplifier.
 
        Parameters
        ----------
        detector : `lsst.afw.cameraGeom.Detector`, optional
            Detector to validate, along with its amplifiers.
        amplifier : `lsst.afw.cameraGeom.Amplifier`, optional
            Single amplifier to validate.
 
        Raises
        ------
        RuntimeError
            Raised if there is a mismatch in linearity parameters, and
            the cameraGeom parameters are not being overridden.
        """
        amplifiersToCheck = []
        if detector:
            if self._detectorName != detector.getName():
                raise RuntimeError("Detector names don't match: %s != %s" %
                                   (self._detectorName, detector.getName()))
            if int(self._detectorId) != int(detector.getId()):
                raise RuntimeError("Detector IDs don't match: %s != %s" %
                                   (int(self._detectorId), int(detector.getId())))
            # TODO: DM-38778: This check fails on LATISS due to an
            #                 error in the camera configuration.
            # if self._detectorSerial != detector.getSerial():
            #      raise RuntimeError(
            #          "Detector serial numbers don't match: %s != %s" %
            #          (self._detectorSerial, detector.getSerial()))
            if len(detector.getAmplifiers()) != len(self.linearityCoeffs.keys()):
                raise RuntimeError("Detector number of amps = %s does not match saved value %s" %
                                   (len(detector.getAmplifiers()),
                                    len(self.linearityCoeffs.keys())))
            amplifiersToCheck.extend(detector.getAmplifiers())
 
        if amplifier:
            amplifiersToCheck.extend(amplifier)
 
        for amp in amplifiersToCheck:
            ampName = amp.getName()
            if ampName not in self.linearityCoeffs.keys():
                raise RuntimeError("Amplifier %s is not in linearity data" %
                                   (ampName, ))
            if amp.getLinearityType() != self.linearityType[ampName]:
                if self.override:
                    self.log.debug("Overriding amplifier defined linearityType (%s) for %s",
                                   self.linearityType[ampName], ampName)
                else:
                    raise RuntimeError("Amplifier %s type %s does not match saved value %s" %
                                       (ampName, amp.getLinearityType(), self.linearityType[ampName]))
            if (amp.getLinearityCoeffs().shape != self.linearityCoeffs[ampName].shape or not
                    np.allclose(amp.getLinearityCoeffs(), self.linearityCoeffs[ampName], equal_nan=True)):
                if self.override:
                    self.log.debug("Overriding amplifier defined linearityCoeffs (%s) for %s",
                                   self.linearityCoeffs[ampName], ampName)
                else:
                    raise RuntimeError("Amplifier %s coeffs %s does not match saved value %s" %
                                       (ampName, amp.getLinearityCoeffs(), self.linearityCoeffs[ampName]))
 

Member Data Documentation

◆ _detectorId

lsst.ip.isr.linearize.Linearizer._detectorId

protected

Definition at line 185 of file linearize.py.

◆ _detectorName

lsst.ip.isr.linearize.Linearizer._detectorName

protected

Definition at line 183 of file linearize.py.

◆ _detectorSerial

lsst.ip.isr.linearize.Linearizer._detectorSerial

protected

Definition at line 184 of file linearize.py.

◆ _OBSTYPE

str lsst.ip.isr.linearize.Linearizer._OBSTYPE = "LINEARIZER"

staticprotected

Definition at line 109 of file linearize.py.

◆ _SCHEMA

str lsst.ip.isr.linearize.Linearizer._SCHEMA = 'Gen3 Linearizer'

staticprotected

Definition at line 110 of file linearize.py.

◆ _VERSION

float lsst.ip.isr.linearize.Linearizer._VERSION = 1.4

staticprotected

Definition at line 111 of file linearize.py.

◆ ampNames

lsst.ip.isr.linearize.Linearizer.ampNames

Definition at line 117 of file linearize.py.

◆ fitChiSq

lsst.ip.isr.linearize.Linearizer.fitChiSq

Definition at line 123 of file linearize.py.

◆ fitParams

lsst.ip.isr.linearize.Linearizer.fitParams

Definition at line 121 of file linearize.py.

◆ fitParamsErr

lsst.ip.isr.linearize.Linearizer.fitParamsErr

Definition at line 122 of file linearize.py.

◆ fitResiduals

lsst.ip.isr.linearize.Linearizer.fitResiduals

Definition at line 124 of file linearize.py.

◆ fitResidualsSigmaMad

lsst.ip.isr.linearize.Linearizer.fitResidualsSigmaMad

Definition at line 125 of file linearize.py.

◆ hasLinearity

lsst.ip.isr.linearize.Linearizer.hasLinearity

Definition at line 114 of file linearize.py.

◆ linearFit

lsst.ip.isr.linearize.Linearizer.linearFit

Definition at line 126 of file linearize.py.

◆ linearityBBox

lsst.ip.isr.linearize.Linearizer.linearityBBox

Definition at line 120 of file linearize.py.

◆ linearityCoeffs

lsst.ip.isr.linearize.Linearizer.linearityCoeffs

Definition at line 118 of file linearize.py.

◆ linearityMaxSignal

lsst.ip.isr.linearize.Linearizer.linearityMaxSignal

Definition at line 128 of file linearize.py.

◆ linearityTurnoff

lsst.ip.isr.linearize.Linearizer.linearityTurnoff

Definition at line 127 of file linearize.py.

◆ linearityType

lsst.ip.isr.linearize.Linearizer.linearityType

Definition at line 119 of file linearize.py.

◆ linearityUnits

lsst.ip.isr.linearize.Linearizer.linearityUnits

Definition at line 139 of file linearize.py.

◆ log

lsst.ip.isr.linearize.Linearizer.log

Definition at line 555 of file linearize.py.

◆ override

lsst.ip.isr.linearize.Linearizer.override

Definition at line 115 of file linearize.py.

◆ tableData

lsst.ip.isr.linearize.Linearizer.tableData

Definition at line 129 of file linearize.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/ip_isr/gfb92a5be7c+9c285cab97/python/lsst/ip/isr/linearize.py

Public Member Functions

Public Attributes

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ applyLinearity()

◆ fromDetector()

◆ fromDict()

◆ fromTable()

◆ getLinearityTypeByName()

◆ toDict()

◆ toTable()

◆ updateMetadata()

◆ validate()

Member Data Documentation

◆ _detectorId

◆ _detectorName

◆ _detectorSerial

◆ _OBSTYPE

◆ _SCHEMA

◆ _VERSION

◆ ampNames

◆ fitChiSq

◆ fitParams

◆ fitParamsErr

◆ fitResiduals

◆ fitResidualsSigmaMad

◆ hasLinearity

◆ linearFit

◆ linearityBBox

◆ linearityCoeffs

◆ linearityMaxSignal

◆ linearityTurnoff

◆ linearityType

◆ linearityUnits

◆ log

◆ override

◆ tableData

◆ init()