lsst.cp.pipe.cpCombine.CalibCombineByFilterTask Class Reference

Inheritance diagram for lsst.cp.pipe.cpCombine.CalibCombineByFilterTask:

Public Member Functions
def	runQuantum (self, butlerQC, inputRefs, outputRefs)
def	run (self, inputExps, inputScales=None, inputDims=None)
def	getDimensions (self, expList)
def	getSize (self, dimList)
def	applyScale (self, exposure, scale=None)
def	combine (self, target, expList, stats)
def	combineHeaders (self, expList, calib, calibType="CALIB", scales=None)
def	interpolateNans (self, exp)

Static Public Attributes
	ConfigClass = CalibCombineByFilterConfig

Detailed Description

Task to combine calib exposures.

Definition at line 551 of file cpCombine.py.

Member Function Documentation

applyScale()

def lsst.cp.pipe.cpCombine.CalibCombineTask.applyScale (   self,   exposure,   scale = None  )

inherited

Apply scale to input exposure.

This implementation applies a flux scaling: the input exposure is
divided by the provided scale.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to scale.
scale : `float` or `list` [`float`], optional
    Constant scale to divide the exposure by.

Definition at line 381 of file cpCombine.py.

    def applyScale(self, exposure, scale=None):
        """Apply scale to input exposure.
 
        This implementation applies a flux scaling: the input exposure is
        divided by the provided scale.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure to scale.
        scale : `float` or `list` [`float`], optional
            Constant scale to divide the exposure by.
        """
        if scale is not None:
            mi = exposure.getMaskedImage()
            if isinstance(scale, list):
                for amp, ampScale in zip(exposure.getDetector(), scale):
                    ampIm = mi[amp.getBBox()]
                    ampIm /= ampScale
            else:
                mi /= scale
 

combine()

def lsst.cp.pipe.cpCombine.CalibCombineTask.combine (   self,   target,   expList,   stats  )

inherited

Combine multiple images.

Parameters
----------
target : `lsst.afw.image.Exposure`
    Output exposure to construct.
expList : `list` [`lsst.afw.image.Exposure`]
    Input exposures to combine.
stats : `lsst.afw.math.StatisticsControl`
    Control explaining how to combine the input images.

Definition at line 403 of file cpCombine.py.

    def combine(self, target, expList, stats):
        """Combine multiple images.
 
        Parameters
        ----------
        target : `lsst.afw.image.Exposure`
            Output exposure to construct.
        expList : `list` [`lsst.afw.image.Exposure`]
            Input exposures to combine.
        stats : `lsst.afw.math.StatisticsControl`
            Control explaining how to combine the input images.
        """
        images = [img.getMaskedImage() for img in expList if img is not None]
        combineType = afwMath.stringToStatisticsProperty(self.config.combine)
        afwMath.statisticsStack(target, images, combineType, stats)
 

combineHeaders()

def lsst.cp.pipe.cpCombine.CalibCombineTask.combineHeaders (   self,   expList,   calib,   calibType = "CALIB",   scales = None  )

inherited

Combine input headers to determine the set of common headers,
supplemented by calibration inputs.

Parameters
----------
expList : `list` of `lsst.afw.image.Exposure`
    Input list of exposures to combine.
calib : `lsst.afw.image.Exposure`
    Output calibration to construct headers for.
calibType: `str`, optional
    OBSTYPE the output should claim.
scales: `list` of `float`, optional
    Scale values applied to each input to record.

Returns
-------
header : `lsst.daf.base.PropertyList`
    Constructed header.

Definition at line 419 of file cpCombine.py.

    def combineHeaders(self, expList, calib, calibType="CALIB", scales=None):
        """Combine input headers to determine the set of common headers,
        supplemented by calibration inputs.
 
        Parameters
        ----------
        expList : `list` of `lsst.afw.image.Exposure`
            Input list of exposures to combine.
        calib : `lsst.afw.image.Exposure`
            Output calibration to construct headers for.
        calibType: `str`, optional
            OBSTYPE the output should claim.
        scales: `list` of `float`, optional
            Scale values applied to each input to record.
 
        Returns
        -------
        header : `lsst.daf.base.PropertyList`
            Constructed header.
        """
        # Header
        header = calib.getMetadata()
        header.set("OBSTYPE", calibType)
 
        # Keywords we care about
        comments = {"TIMESYS": "Time scale for all dates",
                    "DATE-OBS": "Start date of earliest input observation",
                    "MJD-OBS": "[d] Start MJD of earliest input observation",
                    "DATE-END": "End date of oldest input observation",
                    "MJD-END": "[d] End MJD of oldest input observation",
                    "MJD-AVG": "[d] MJD midpoint of all input observations",
                    "DATE-AVG": "Midpoint date of all input observations"}
 
        # Creation date
        now = time.localtime()
        calibDate = time.strftime("%Y-%m-%d", now)
        calibTime = time.strftime("%X %Z", now)
        header.set("CALIB_CREATE_DATE", calibDate)
        header.set("CALIB_CREATE_TIME", calibTime)
 
        # Merge input headers
        inputHeaders = [exp.getMetadata() for exp in expList if exp is not None]
        merged = merge_headers(inputHeaders, mode='drop')
        for k, v in merged.items():
            if k not in header:
                md = expList[0].getMetadata()
                comment = md.getComment(k) if k in md else None
                header.set(k, v, comment=comment)
 
        # Construct list of visits
        visitInfoList = [exp.getInfo().getVisitInfo() for exp in expList if exp is not None]
        for i, visit in enumerate(visitInfoList):
            if visit is None:
                continue
            header.set("CPP_INPUT_%d" % (i,), visit.getExposureId())
            header.set("CPP_INPUT_DATE_%d" % (i,), str(visit.getDate()))
            header.set("CPP_INPUT_EXPT_%d" % (i,), visit.getExposureTime())
            if scales is not None:
                header.set("CPP_INPUT_SCALE_%d" % (i,), scales[i])
 
        # Not yet working: DM-22302
        # Create an observation group so we can add some standard headers
        # independent of the form in the input files.
        # Use try block in case we are dealing with unexpected data headers
        try:
            group = ObservationGroup(visitInfoList, pedantic=False)
        except Exception:
            self.log.warn("Exception making an obs group for headers. Continuing.")
            # Fall back to setting a DATE-OBS from the calibDate
            dateCards = {"DATE-OBS": "{}T00:00:00.00".format(calibDate)}
            comments["DATE-OBS"] = "Date of start of day of calibration midpoint"
        else:
            oldest, newest = group.extremes()
            dateCards = dates_to_fits(oldest.datetime_begin, newest.datetime_end)
 
        for k, v in dateCards.items():
            header.set(k, v, comment=comments.get(k, None))
 
        return header
 

getDimensions()

def lsst.cp.pipe.cpCombine.CalibCombineTask.getDimensions (   self,   expList  )

inherited

Get dimensions of the inputs.

Parameters
----------
expList : `list` [`lsst.afw.image.Exposure`]
    Exps to check the sizes of.

Returns
-------
width, height : `int`
    Unique set of input dimensions.

Definition at line 342 of file cpCombine.py.

    def getDimensions(self, expList):
        """Get dimensions of the inputs.
 
        Parameters
        ----------
        expList : `list` [`lsst.afw.image.Exposure`]
            Exps to check the sizes of.
 
        Returns
        -------
        width, height : `int`
            Unique set of input dimensions.
        """
        dimList = [exp.getDimensions() for exp in expList if exp is not None]
        return self.getSize(dimList)
 

getSize()

def lsst.cp.pipe.cpCombine.CalibCombineTask.getSize (   self,   dimList  )

inherited

Determine a consistent size, given a list of image sizes.

Parameters
-----------
dimList : iterable of `tuple` (`int`, `int`)
    List of dimensions.

Raises
------
RuntimeError
    If input dimensions are inconsistent.

Returns
--------
width, height : `int`
    Common dimensions.

Definition at line 358 of file cpCombine.py.

    def getSize(self, dimList):
        """Determine a consistent size, given a list of image sizes.
 
        Parameters
        -----------
        dimList : iterable of `tuple` (`int`, `int`)
            List of dimensions.
 
        Raises
        ------
        RuntimeError
            If input dimensions are inconsistent.
 
        Returns
        --------
        width, height : `int`
            Common dimensions.
        """
        dim = set((w, h) for w, h in dimList)
        if len(dim) != 1:
            raise RuntimeError("Inconsistent dimensions: %s" % dim)
        return dim.pop()
 

interpolateNans()

def lsst.cp.pipe.cpCombine.CalibCombineTask.interpolateNans (   self,   exp  )

inherited

Interpolate over NANs in the combined image.

NANs can result from masked areas on the CCD.  We don't want them getting
into our science images, so we replace them with the median of the image.

Parameters
----------
exp : `lsst.afw.image.Exposure`
    Exp to check for NaNs.

Definition at line 499 of file cpCombine.py.

    def interpolateNans(self, exp):
        """Interpolate over NANs in the combined image.
 
        NANs can result from masked areas on the CCD.  We don't want them getting
        into our science images, so we replace them with the median of the image.
 
        Parameters
        ----------
        exp : `lsst.afw.image.Exposure`
            Exp to check for NaNs.
        """
        array = exp.getImage().getArray()
        bad = np.isnan(array)
 
        median = np.median(array[np.logical_not(bad)])
        count = np.sum(np.logical_not(bad))
        array[bad] = median
        if count > 0:
            self.log.warn("Found %s NAN pixels", count)
 
 
# Create versions of the Connections, Config, and Task that support filter constraints.

run()

def lsst.cp.pipe.cpCombine.CalibCombineTask.run (   self,   inputExps,   inputScales = None,   inputDims = None  )

inherited

Combine calib exposures for a single detector.

Parameters
----------
inputExps : `list` [`lsst.afw.image.Exposure`]
    Input list of exposures to combine.
inputScales : `dict` [`dict` [`dict` [`float`]]], optional
    Dictionary of scales, indexed by detector (`int`),
    amplifier (`int`), and exposure (`int`).  Used for
    'inputList' scaling.
inputDims : `list` [`dict`]
    List of dictionaries of input data dimensions/values.
    Each list entry should contain:

    ``"exposure"``
        exposure id value (`int`)
    ``"detector"``
        detector id value (`int`)

Returns
-------
combinedExp : `lsst.afw.image.Exposure`
    Final combined exposure generated from the inputs.

Raises
------
RuntimeError
    Raised if no input data is found.  Also raised if
    config.exposureScaling == InputList, and a necessary scale
    was not found.

Definition at line 216 of file cpCombine.py.

    def run(self, inputExps, inputScales=None, inputDims=None):
        """Combine calib exposures for a single detector.
 
        Parameters
        ----------
        inputExps : `list` [`lsst.afw.image.Exposure`]
            Input list of exposures to combine.
        inputScales : `dict` [`dict` [`dict` [`float`]]], optional
            Dictionary of scales, indexed by detector (`int`),
            amplifier (`int`), and exposure (`int`).  Used for
            'inputList' scaling.
        inputDims : `list` [`dict`]
            List of dictionaries of input data dimensions/values.
            Each list entry should contain:
 
            ``"exposure"``
                exposure id value (`int`)
            ``"detector"``
                detector id value (`int`)
 
        Returns
        -------
        combinedExp : `lsst.afw.image.Exposure`
            Final combined exposure generated from the inputs.
 
        Raises
        ------
        RuntimeError
            Raised if no input data is found.  Also raised if
            config.exposureScaling == InputList, and a necessary scale
            was not found.
        """
        width, height = self.getDimensions(inputExps)
        stats = afwMath.StatisticsControl(self.config.clip, self.config.nIter,
                                          afwImage.Mask.getPlaneBitMask(self.config.mask))
        numExps = len(inputExps)
        if numExps < 1:
            raise RuntimeError("No valid input data")
        if numExps < self.config.maxVisitsToCalcErrorFromInputVariance:
            stats.setCalcErrorFromInputVariance(True)
 
        # Check that all inputs either share the same detector (based
        # on detId), or that no inputs have any detector.
        detectorList = [exp.getDetector() for exp in inputExps]
        if None in detectorList:
            self.log.warn("Not all input detectors defined.")
        detectorIds = [det.getId() if det is not None else None for det in detectorList]
        detectorSerials = [det.getId() if det is not None else None for det in detectorList]
        numDetectorIds = len(set(detectorIds))
        numDetectorSerials = len(set(detectorSerials))
        numDetectors = len(set([numDetectorIds, numDetectorSerials]))
        if numDetectors != 1:
            raise RuntimeError("Input data contains multiple detectors.")
 
        inputDetector = inputExps[0].getDetector()
 
        # Create output exposure for combined data.
        combined = afwImage.MaskedImageF(width, height)
        combinedExp = afwImage.makeExposure(combined)
 
        # Apply scaling:
        expScales = []
        if inputDims is None:
            inputDims = [dict() for i in inputExps]
 
        for index, (exp, dims) in enumerate(zip(inputExps, inputDims)):
            scale = 1.0
            if exp is None:
                self.log.warn("Input %d is None (%s); unable to scale exp.", index, dims)
                continue
 
            if self.config.exposureScaling == "ExposureTime":
                scale = exp.getInfo().getVisitInfo().getExposureTime()
            elif self.config.exposureScaling == "DarkTime":
                scale = exp.getInfo().getVisitInfo().getDarkTime()
            elif self.config.exposureScaling == "MeanStats":
                scale = self.stats.run(exp)
            elif self.config.exposureScaling == "InputList":
                visitId = dims.get('exposure', None)
                detectorId = dims.get('detector', None)
                if visitId is None or detectorId is None:
                    raise RuntimeError(f"Could not identify scaling for input {index} ({dims})")
                if detectorId not in inputScales['expScale']:
                    raise RuntimeError(f"Could not identify a scaling for input {index}"
                                       f" detector {detectorId}")
 
                if self.config.scalingLevel == "DETECTOR":
                    if visitId not in inputScales['expScale'][detectorId]:
                        raise RuntimeError(f"Could not identify a scaling for input {index}"
                                           f"detector {detectorId} visit {visitId}")
                    scale = inputScales['expScale'][detectorId][visitId]
                elif self.config.scalingLevel == 'AMP':
                    scale = [inputScales['expScale'][detectorId][amp.getName()][visitId]
                             for amp in exp.getDetector()]
                else:
                    raise RuntimeError(f"Unknown scaling level: {self.config.scalingLevel}")
            elif self.config.exposureScaling == 'Unity':
                scale = 1.0
            else:
                raise RuntimeError(f"Unknown scaling type: {self.config.exposureScaling}.")
 
            expScales.append(scale)
            self.log.info("Scaling input %d by %s", index, scale)
            self.applyScale(exp, scale)
 
        self.combine(combined, inputExps, stats)
 
        self.interpolateNans(combined)
 
        if self.config.doVignette:
            polygon = inputExps[0].getInfo().getValidPolygon()
            VignetteExposure(combined, polygon=polygon, doUpdateMask=True,
                             doSetValue=True, vignetteValue=0.0)
 
        # Combine headers
        self.combineHeaders(inputExps, combinedExp,
                            calibType=self.config.calibrationType, scales=expScales)
 
        # Set the detector
        combinedExp.setDetector(inputDetector)
 
        # Return
        return pipeBase.Struct(
            outputData=combinedExp,
        )
 

runQuantum()

def lsst.cp.pipe.cpCombine.CalibCombineTask.runQuantum (   self,   butlerQC,   inputRefs,   outputRefs  )

inherited

Definition at line 207 of file cpCombine.py.

    def runQuantum(self, butlerQC, inputRefs, outputRefs):
        inputs = butlerQC.get(inputRefs)
 
        dimensions = [exp.dataId.byName() for exp in inputRefs.inputExps]
        inputs['inputDims'] = dimensions
 
        outputs = self.run(**inputs)
        butlerQC.put(outputs, outputRefs)
 

Member Data Documentation

ConfigClass

lsst.cp.pipe.cpCombine.CalibCombineByFilterTask.ConfigClass = CalibCombineByFilterConfig

static

Definition at line 553 of file cpCombine.py.

---

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

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