lsst.ip.isr.linearize.Linearizer Class Reference

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)
	requiredAttributes (self)
	requiredAttributes (self, value)
	__str__ (self)
	__eq__ (self, other)
	metadata (self)
	getMetadata (self)
	setMetadata (self, metadata)
	updateMetadataFromExposures (self, exposures)
	calibInfoFromDict (self, dictionary)
	determineCalibClass (cls, metadata, message)
	readText (cls, filename, **kwargs)
	writeText (self, filename, format="auto")
	readFits (cls, filename, **kwargs)
	writeFits (self, filename)
	apply (self, target)

Public Attributes
bool	hasLinearity = False
bool	override = False
	ampNames = list()
	linearityCoeffs = dict()
	linearityType = dict()
	linearityBBox = dict()
	fitParams = dict()
	fitParamsErr = dict()
	fitChiSq = dict()
	fitResiduals = dict()
	fitResidualsSigmaMad = dict()
	linearFit = dict()
	linearityTurnoff = dict()
	linearityMaxSignal = dict()
	tableData = None
str	linearityUnits = 'adu'
	requiredAttributes = set(["_OBSTYPE", "_SCHEMA", "_VERSION"])
	log = log if log else logging.getLogger(__name__)

Protected Attributes
	_instrument = None
	_raftName = None
	_slotName = None
	_detectorName = None
	_detectorSerial = None
	_detectorId = None
	_filter = None
str	_calibId = None
	_seqfile = None
	_seqname = None
	_seqcksum = None
	_metadata = PropertyList()
	_requiredAttributes

Static Protected Attributes
str	_OBSTYPE = "generic"
str	_SCHEMA = "NO SCHEMA"
int	_VERSION = 0

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 )

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

__eq__()

lsst.ip.isr.calibType.IsrCalib.__eq__ ( self, other )

inherited

Calibration equivalence.

Running ``calib.log.setLevel(0)`` enables debug statements to
identify problematic fields.

Definition at line 103 of file calibType.py.

    def __eq__(self, other):
        """Calibration equivalence.
 
        Running ``calib.log.setLevel(0)`` enables debug statements to
        identify problematic fields.
        """
        if not isinstance(other, self.__class__):
            self.log.debug("Incorrect class type: %s %s", self.__class__, other.__class__)
            return False
 
        for attr in self._requiredAttributes:
            attrSelf = getattr(self, attr)
            attrOther = getattr(other, attr)
 
            if isinstance(attrSelf, dict):
                # Dictionary of arrays.
                if attrSelf.keys() != attrOther.keys():
                    self.log.debug("Dict Key Failure: %s %s %s", attr, attrSelf.keys(), attrOther.keys())
                    return False
                for key in attrSelf:
                    try:
                        if not np.allclose(attrSelf[key], attrOther[key], equal_nan=True):
                            self.log.debug("Array Failure: %s %s %s", key, attrSelf[key], attrOther[key])
                            return False
                    except TypeError:
                        # If it is not something numpy can handle
                        # (it's not a number or array of numbers),
                        # then it needs to have its own equivalence
                        # operator.
                        if np.all(attrSelf[key] != attrOther[key]):
                            return False
            elif isinstance(attrSelf, np.ndarray):
                # Bare array.
                if isinstance(attrSelf[0], (str, np.str_, np.bytes_)):
                    if not np.all(attrSelf == attrOther):
                        self.log.debug("Array Failure: %s %s %s", attr, attrSelf, attrOther)
                        return False
                else:
                    if not np.allclose(attrSelf, attrOther, equal_nan=True):
                        self.log.debug("Array Failure: %s %s %s", attr, attrSelf, attrOther)
                        return False
            elif type(attrSelf) is not type(attrOther):
                if set([attrSelf, attrOther]) == set([None, ""]):
                    # Fits converts None to "", but None is not "".
                    continue
                self.log.debug("Type Failure: %s %s %s %s %s", attr, type(attrSelf), type(attrOther),
                               attrSelf, attrOther)
                return False
            else:
                if attrSelf != attrOther:
                    self.log.debug("Value Failure: %s %s %s", attr, attrSelf, attrOther)
                    return False
 
        return True
 

__str__()

lsst.ip.isr.calibType.IsrCalib.__str__ ( self )

inherited

Definition at line 100 of file calibType.py.

    def __str__(self):
        return f"{self.__class__.__name__}(obstype={self._OBSTYPE}, detector={self._detectorName}, )"
 

apply()

lsst.ip.isr.calibType.IsrCalib.apply ( self, target )

inherited

Method to apply the calibration to the target object.

Parameters
----------
target : `object`
    Thing to validate against.

Returns
-------
valid : `bool`
    Returns true if the calibration was applied correctly.

Raises
------
NotImplementedError
    Raised if not implemented.

Definition at line 685 of file calibType.py.

    def apply(self, target):
        """Method to apply the calibration to the target object.
 
        Parameters
        ----------
        target : `object`
            Thing to validate against.
 
        Returns
        -------
        valid : `bool`
            Returns true if the calibration was applied correctly.
 
        Raises
        ------
        NotImplementedError
            Raised if not implemented.
        """
        raise NotImplementedError("Must be implemented by subclass.")
 
 

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
        )
 
 

calibInfoFromDict()

lsst.ip.isr.calibType.IsrCalib.calibInfoFromDict ( self, dictionary )

inherited

Handle common keywords.

This isn't an ideal solution, but until all calibrations
expect to find everything in the metadata, they still need to
search through dictionaries.

Parameters
----------
dictionary : `dict` or `lsst.daf.base.PropertyList`
    Source for the common keywords.

Raises
------
RuntimeError
    Raised if the dictionary does not match the expected OBSTYPE.

Definition at line 322 of file calibType.py.

    def calibInfoFromDict(self, dictionary):
        """Handle common keywords.
 
        This isn't an ideal solution, but until all calibrations
        expect to find everything in the metadata, they still need to
        search through dictionaries.
 
        Parameters
        ----------
        dictionary : `dict` or `lsst.daf.base.PropertyList`
            Source for the common keywords.
 
        Raises
        ------
        RuntimeError
            Raised if the dictionary does not match the expected OBSTYPE.
        """
 
        def search(haystack, needles):
            """Search dictionary 'haystack' for an entry in 'needles'
            """
            test = [haystack.get(x) for x in needles]
            test = set([x for x in test if x is not None])
            if len(test) == 0:
                if "metadata" in haystack:
                    return search(haystack["metadata"], needles)
                else:
                    return None
            elif len(test) == 1:
                value = list(test)[0]
                if value == "":
                    return None
                else:
                    return value
            else:
                raise ValueError(f"Too many values found: {len(test)} {test} {needles}")
 
        if "metadata" in dictionary:
            metadata = dictionary["metadata"]
 
            if self._OBSTYPE != metadata["OBSTYPE"]:
                raise RuntimeError(f"Incorrect calibration supplied.  Expected {self._OBSTYPE}, "
                                   f"found {metadata['OBSTYPE']}")
 
        if (value := search(dictionary, ["INSTRUME", "instrument"])) is not None:
            self._instrument = value
        if (value := search(dictionary, ["RAFTNAME"])) is not None:
            self._slotName = value
        if (value := search(dictionary, ["DETECTOR", "detectorId"])) is not None:
            self._detectorId = value
        if (value := search(dictionary, ["DET_NAME", "DETECTOR_NAME", "detectorName"])) is not None:
            self._detectorName = value
        if (value := search(dictionary, ["DET_SER", "DETECTOR_SERIAL", "detectorSerial"])) is not None:
            self._detectorSerial = value
        if (value := search(dictionary, ["FILTER", "filterName"])) is not None:
            self._filter = value
        if (value := search(dictionary, ["CALIB_ID"])) is not None:
            self._calibId = value
        if (value := search(dictionary, ["SEQFILE"])) is not None:
            self._seqfile = value
        if (value := search(dictionary, ["SEQNAME"])) is not None:
            self._seqname = value
        if (value := search(dictionary, ["SEQCKSUM"])) is not None:
            self._seqcksum = value
 

determineCalibClass()

lsst.ip.isr.calibType.IsrCalib.determineCalibClass ( cls, metadata, message )

inherited

Attempt to find calibration class in metadata.

Parameters
----------
metadata : `dict` or `lsst.daf.base.PropertyList`
    Metadata possibly containing a calibration class entry.
message : `str`
    Message to include in any errors.

Returns
-------
calibClass : `object`
    The class to use to read the file contents.  Should be an
    `lsst.ip.isr.IsrCalib` subclass.

Raises
------
ValueError
    Raised if the resulting calibClass is the base
    `lsst.ip.isr.IsrClass` (which does not implement the
    content methods).

Definition at line 388 of file calibType.py.

    def determineCalibClass(cls, metadata, message):
        """Attempt to find calibration class in metadata.
 
        Parameters
        ----------
        metadata : `dict` or `lsst.daf.base.PropertyList`
            Metadata possibly containing a calibration class entry.
        message : `str`
            Message to include in any errors.
 
        Returns
        -------
        calibClass : `object`
            The class to use to read the file contents.  Should be an
            `lsst.ip.isr.IsrCalib` subclass.
 
        Raises
        ------
        ValueError
            Raised if the resulting calibClass is the base
            `lsst.ip.isr.IsrClass` (which does not implement the
            content methods).
        """
        calibClassName = metadata.get("CALIBCLS")
        calibClass = doImport(calibClassName) if calibClassName is not None else cls
        if calibClass is IsrCalib:
            raise ValueError(f"Cannot use base class to read calibration data: {message}")
        return calibClass
 

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
 

getMetadata()

lsst.ip.isr.calibType.IsrCalib.getMetadata ( self )

inherited

Retrieve metadata associated with this calibration.

Returns
-------
meta : `lsst.daf.base.PropertyList`
    Metadata. The returned `~lsst.daf.base.PropertyList` can be
    modified by the caller and the changes will be written to
    external files.

Definition at line 171 of file calibType.py.

    def getMetadata(self):
        """Retrieve metadata associated with this calibration.
 
        Returns
        -------
        meta : `lsst.daf.base.PropertyList`
            Metadata. The returned `~lsst.daf.base.PropertyList` can be
            modified by the caller and the changes will be written to
            external files.
        """
        return self._metadata
 

metadata()

lsst.ip.isr.calibType.IsrCalib.metadata ( self )

inherited

Definition at line 168 of file calibType.py.

    def metadata(self):
        return self._metadata
 

readFits()

lsst.ip.isr.calibType.IsrCalib.readFits ( cls, filename, ** kwargs )

inherited

Read calibration data from a FITS file.

Parameters
----------
filename : `str`
    Filename to read data from.
kwargs : `dict` or collections.abc.Mapping`, optional
    Set of key=value pairs to pass to the ``fromTable``
    method.

Returns
-------
calib : `lsst.ip.isr.IsrCalib`
    Calibration contained within the file.

Definition at line 505 of file calibType.py.

    def readFits(cls, filename, **kwargs):
        """Read calibration data from a FITS file.
 
        Parameters
        ----------
        filename : `str`
            Filename to read data from.
        kwargs : `dict` or collections.abc.Mapping`, optional
            Set of key=value pairs to pass to the ``fromTable``
            method.
 
        Returns
        -------
        calib : `lsst.ip.isr.IsrCalib`
            Calibration contained within the file.
        """
        tableList = []
        tableList.append(Table.read(filename, hdu=1, mask_invalid=False))
        extNum = 2  # Fits indices start at 1, we've read one already.
        keepTrying = True
 
        while keepTrying:
            with warnings.catch_warnings():
                warnings.simplefilter("error")
                try:
                    newTable = Table.read(filename, hdu=extNum, mask_invalid=False)
                    tableList.append(newTable)
                    extNum += 1
                except Exception:
                    keepTrying = False
 
        for table in tableList:
            for k, v in table.meta.items():
                if isinstance(v, fits.card.Undefined):
                    table.meta[k] = None
 
        calibClass = cls.determineCalibClass(tableList[0].meta, "readFits")
        return calibClass.fromTable(tableList, **kwargs)
 

readText()

lsst.ip.isr.calibType.IsrCalib.readText ( cls, filename, ** kwargs )

inherited

Read calibration representation from a yaml/ecsv file.

Parameters
----------
filename : `str`
    Name of the file containing the calibration definition.
kwargs : `dict` or collections.abc.Mapping`, optional
    Set of key=value pairs to pass to the ``fromDict`` or
    ``fromTable`` methods.

Returns
-------
calib : `~lsst.ip.isr.IsrCalibType`
    Calibration class.

Raises
------
RuntimeError
    Raised if the filename does not end in ".ecsv" or ".yaml".

Definition at line 418 of file calibType.py.

    def readText(cls, filename, **kwargs):
        """Read calibration representation from a yaml/ecsv file.
 
        Parameters
        ----------
        filename : `str`
            Name of the file containing the calibration definition.
        kwargs : `dict` or collections.abc.Mapping`, optional
            Set of key=value pairs to pass to the ``fromDict`` or
            ``fromTable`` methods.
 
        Returns
        -------
        calib : `~lsst.ip.isr.IsrCalibType`
            Calibration class.
 
        Raises
        ------
        RuntimeError
            Raised if the filename does not end in ".ecsv" or ".yaml".
        """
        if filename.endswith((".ecsv", ".ECSV")):
            data = Table.read(filename, format="ascii.ecsv")
            calibClass = cls.determineCalibClass(data.meta, "readText/ECSV")
            return calibClass.fromTable([data], **kwargs)
        elif filename.endswith((".yaml", ".YAML")):
            with open(filename, "r") as f:
                data = yaml.load(f, Loader=yaml.CLoader)
            calibClass = cls.determineCalibClass(data["metadata"], "readText/YAML")
            return calibClass.fromDict(data, **kwargs)
        else:
            raise RuntimeError(f"Unknown filename extension: {filename}")
 

requiredAttributes() [1/2]

lsst.ip.isr.calibType.IsrCalib.requiredAttributes ( self )

inherited

Definition at line 159 of file calibType.py.

    def requiredAttributes(self):
        return self._requiredAttributes
 

requiredAttributes() [2/2]

lsst.ip.isr.calibType.IsrCalib.requiredAttributes ( self, value )

inherited

Definition at line 163 of file calibType.py.

    def requiredAttributes(self, value):
        self._requiredAttributes = value
 

setMetadata()

lsst.ip.isr.calibType.IsrCalib.setMetadata ( self, metadata )

inherited

Store a copy of the supplied metadata with this calibration.

Parameters
----------
metadata : `lsst.daf.base.PropertyList`
    Metadata to associate with the calibration.  Will be copied and
    overwrite existing metadata.

Reimplemented in lsst.ip.isr.transmissionCurve.IntermediateTransmissionCurve.

Definition at line 183 of file calibType.py.

    def setMetadata(self, metadata):
        """Store a copy of the supplied metadata with this calibration.
 
        Parameters
        ----------
        metadata : `lsst.daf.base.PropertyList`
            Metadata to associate with the calibration.  Will be copied and
            overwrite existing metadata.
        """
        if metadata is not None:
            self._metadata.update(metadata)
 
        # Ensure that we have the obs type required by calibration ingest
        self._metadata["OBSTYPE"] = self._OBSTYPE
        self._metadata[self._OBSTYPE + "_SCHEMA"] = self._SCHEMA
        self._metadata[self._OBSTYPE + "_VERSION"] = self._VERSION
 
        if isinstance(metadata, dict):
            self.calibInfoFromDict(metadata)
        elif isinstance(metadata, PropertyList):
            self.calibInfoFromDict(metadata.toDict())
 

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)
 

updateMetadataFromExposures()

lsst.ip.isr.calibType.IsrCalib.updateMetadataFromExposures ( self, exposures )

inherited

Extract and unify metadata information.

Parameters
----------
exposures : `list`
    Exposures or other calibrations to scan.

Definition at line 291 of file calibType.py.

    def updateMetadataFromExposures(self, exposures):
        """Extract and unify metadata information.
 
        Parameters
        ----------
        exposures : `list`
            Exposures or other calibrations to scan.
        """
        # This list of keywords is the set of header entries that
        # should be checked and propagated.  Not having an entry is
        # not a failure, as they may not be defined for the exposures
        # being used.
        keywords = ["SEQNAME", "SEQFILE", "SEQCKSUM", "ODP", "AP0_RC"]
        metadata = {}
 
        for exp in exposures:
            try:
                expMeta = exp.getMetadata()
            except AttributeError:
                continue
            for key in keywords:
                if key in expMeta:
                    if key in metadata:
                        if metadata[key] != expMeta[key]:
                            self.log.warning("Metadata mismatch! Have: %s Found %s",
                                             metadata[key], expMeta[key])
                    else:
                        metadata[key] = expMeta[key]
 
        self.updateMetadata(**metadata, setCalibInfo=True)
 

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]))
 

writeFits()

lsst.ip.isr.calibType.IsrCalib.writeFits ( self, filename )

inherited

Write calibration data to a FITS file.

Parameters
----------
filename : `str`
    Filename to write data to.

Returns
-------
used : `str`
    The name of the file used to write the data.

Reimplemented in lsst.ip.isr.transmissionCurve.IntermediateTransmissionCurve.

Definition at line 544 of file calibType.py.

    def writeFits(self, filename):
        """Write calibration data to a FITS file.
 
        Parameters
        ----------
        filename : `str`
            Filename to write data to.
 
        Returns
        -------
        used : `str`
            The name of the file used to write the data.
        """
        tableList = self.toTable()
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore", category=Warning, module="astropy.io")
            astropyList = [fits.table_to_hdu(table) for table in tableList]
            astropyList.insert(0, fits.PrimaryHDU())
 
            writer = fits.HDUList(astropyList)
            writer.writeto(filename, overwrite=True)
        return filename
 

writeText()

lsst.ip.isr.calibType.IsrCalib.writeText ( self, filename, format = "auto" )

inherited

Write the calibration data to a text file.

Parameters
----------
filename : `str`
    Name of the file to write.
format : `str`
    Format to write the file as.  Supported values are:
        ``"auto"`` : Determine filetype from filename.
        ``"yaml"`` : Write as yaml.
        ``"ecsv"`` : Write as ecsv.

Returns
-------
used : `str`
    The name of the file used to write the data.  This may
    differ from the input if the format is explicitly chosen.

Raises
------
RuntimeError
    Raised if filename does not end in a known extension, or
    if all information cannot be written.

Notes
-----
The file is written to YAML/ECSV format and will include any
associated metadata.

Definition at line 451 of file calibType.py.

    def writeText(self, filename, format="auto"):
        """Write the calibration data to a text file.
 
        Parameters
        ----------
        filename : `str`
            Name of the file to write.
        format : `str`
            Format to write the file as.  Supported values are:
                ``"auto"`` : Determine filetype from filename.
                ``"yaml"`` : Write as yaml.
                ``"ecsv"`` : Write as ecsv.
 
        Returns
        -------
        used : `str`
            The name of the file used to write the data.  This may
            differ from the input if the format is explicitly chosen.
 
        Raises
        ------
        RuntimeError
            Raised if filename does not end in a known extension, or
            if all information cannot be written.
 
        Notes
        -----
        The file is written to YAML/ECSV format and will include any
        associated metadata.
        """
        if format == "yaml" or (format == "auto" and filename.lower().endswith((".yaml", ".YAML"))):
            outDict = self.toDict()
            path, ext = os.path.splitext(filename)
            filename = path + ".yaml"
            with open(filename, "w") as f:
                yaml.dump(outDict, f)
        elif format == "ecsv" or (format == "auto" and filename.lower().endswith((".ecsv", ".ECSV"))):
            tableList = self.toTable()
            if len(tableList) > 1:
                # ECSV doesn't support multiple tables per file, so we
                # can only write the first table.
                raise RuntimeError(f"Unable to persist {len(tableList)}tables in ECSV format.")
 
            table = tableList[0]
            path, ext = os.path.splitext(filename)
            filename = path + ".ecsv"
            table.write(filename, format="ascii.ecsv")
        else:
            raise RuntimeError(f"Attempt to write to a file {filename} "
                               "that does not end in '.yaml' or '.ecsv'")
 
        return filename
 

Member Data Documentation

_calibId

str lsst.ip.isr.calibType.IsrCalib._calibId = None

protectedinherited

Definition at line 74 of file calibType.py.

_detectorId

lsst.ip.isr.calibType.IsrCalib._detectorId = None

protectedinherited

Definition at line 72 of file calibType.py.

_detectorName

lsst.ip.isr.calibType.IsrCalib._detectorName = None

protectedinherited

Definition at line 70 of file calibType.py.

_detectorSerial

lsst.ip.isr.calibType.IsrCalib._detectorSerial = None

protectedinherited

Definition at line 71 of file calibType.py.

_filter

lsst.ip.isr.calibType.IsrCalib._filter = None

protectedinherited

Definition at line 73 of file calibType.py.

_instrument

lsst.ip.isr.calibType.IsrCalib._instrument = None

protectedinherited

Definition at line 67 of file calibType.py.

_metadata

lsst.ip.isr.calibType.IsrCalib._metadata = PropertyList()

protectedinherited

Definition at line 78 of file calibType.py.

_OBSTYPE

str lsst.ip.isr.calibType.IsrCalib._OBSTYPE = "generic"

staticprotectedinherited

Definition at line 62 of file calibType.py.

_raftName

lsst.ip.isr.calibType.IsrCalib._raftName = None

protectedinherited

Definition at line 68 of file calibType.py.

_requiredAttributes

lsst.ip.isr.calibType.IsrCalib._requiredAttributes

protectedinherited

Definition at line 113 of file calibType.py.

_SCHEMA

str lsst.ip.isr.calibType.IsrCalib._SCHEMA = "NO SCHEMA"

staticprotectedinherited

Definition at line 63 of file calibType.py.

_seqcksum

lsst.ip.isr.calibType.IsrCalib._seqcksum = None

protectedinherited

Definition at line 77 of file calibType.py.

_seqfile

lsst.ip.isr.calibType.IsrCalib._seqfile = None

protectedinherited

Definition at line 75 of file calibType.py.

_seqname

lsst.ip.isr.calibType.IsrCalib._seqname = None

protectedinherited

Definition at line 76 of file calibType.py.

_slotName

lsst.ip.isr.calibType.IsrCalib._slotName = None

protectedinherited

Definition at line 69 of file calibType.py.

_VERSION

int lsst.ip.isr.calibType.IsrCalib._VERSION = 0

staticprotectedinherited

Definition at line 64 of file calibType.py.

ampNames

lsst.ip.isr.linearize.Linearizer.ampNames = list()

Definition at line 117 of file linearize.py.

fitChiSq

lsst.ip.isr.linearize.Linearizer.fitChiSq = dict()

Definition at line 123 of file linearize.py.

fitParams

lsst.ip.isr.linearize.Linearizer.fitParams = dict()

Definition at line 121 of file linearize.py.

fitParamsErr

lsst.ip.isr.linearize.Linearizer.fitParamsErr = dict()

Definition at line 122 of file linearize.py.

fitResiduals

lsst.ip.isr.linearize.Linearizer.fitResiduals = dict()

Definition at line 124 of file linearize.py.

fitResidualsSigmaMad

lsst.ip.isr.linearize.Linearizer.fitResidualsSigmaMad = dict()

Definition at line 125 of file linearize.py.

hasLinearity

bool lsst.ip.isr.linearize.Linearizer.hasLinearity = False

Definition at line 114 of file linearize.py.

linearFit

lsst.ip.isr.linearize.Linearizer.linearFit = dict()

Definition at line 126 of file linearize.py.

linearityBBox

lsst.ip.isr.linearize.Linearizer.linearityBBox = dict()

Definition at line 120 of file linearize.py.

linearityCoeffs

lsst.ip.isr.linearize.Linearizer.linearityCoeffs = dict()

Definition at line 118 of file linearize.py.

linearityMaxSignal

lsst.ip.isr.linearize.Linearizer.linearityMaxSignal = dict()

Definition at line 128 of file linearize.py.

linearityTurnoff

lsst.ip.isr.linearize.Linearizer.linearityTurnoff = dict()

Definition at line 127 of file linearize.py.

linearityType

lsst.ip.isr.linearize.Linearizer.linearityType = dict()

Definition at line 119 of file linearize.py.

linearityUnits

str lsst.ip.isr.linearize.Linearizer.linearityUnits = 'adu'

Definition at line 139 of file linearize.py.

log

lsst.ip.isr.calibType.IsrCalib.log = log if log else logging.getLogger(__name__)

inherited

Definition at line 94 of file calibType.py.

override

bool lsst.ip.isr.linearize.Linearizer.override = False

Definition at line 115 of file linearize.py.

requiredAttributes

lsst.ip.isr.calibType.IsrCalib.requiredAttributes = set(["_OBSTYPE", "_SCHEMA", "_VERSION"])

inherited

Definition at line 88 of file calibType.py.

tableData

lsst.ip.isr.linearize.Linearizer.tableData = None

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-10.0.0/Linux64/ip_isr/g55585698de+7a33f081c8/python/lsst/ip/isr/linearize.py