lsst.pipe.tasks.assembleCoadd Namespace Reference

Classes
class	AssembleCoaddConnections
class	AssembleCoaddDataIdContainer
class	CompareWarpAssembleCoaddConfig
class	CompareWarpAssembleCoaddConnections
class	CompareWarpAssembleCoaddTask
class	SafeClipAssembleCoaddConfig
class	SafeClipAssembleCoaddTask

Functions
def	processResults (self, coaddExposure, brightObjectMasks=None, dataId=None)
def	makeSupplementaryData (self, dataRef, selectDataList=None, warpRefList=None)
def	makeSupplementaryDataGen3 (self, butlerQC, inputRefs, outputRefs)
def	getTempExpRefList (self, patchRef, calExpRefList)
def	prepareInputs (self, refList)
def	prepareStats (self, mask=None)
def	run (self, skyInfo, tempExpRefList, imageScalerList, weightList, altMaskList=None, mask=None, supplementaryData=None)
def	assembleMetadata (self, coaddExposure, tempExpRefList, weightList)
def	assembleSubregion (self, coaddExposure, bbox, tempExpRefList, imageScalerList, weightList, altMaskList, statsFlags, statsCtrl, nImage=None)
def	assembleOnlineMeanCoadd (self, coaddExposure, tempExpRefList, imageScalerList, weightList, altMaskList, statsCtrl, nImage=None)
def	removeMaskPlanes (self, maskedImage)
def	applyAltMaskPlanes (self, mask, altMaskSpans)
def	shrinkValidPolygons (self, coaddInputs)
def	readBrightObjectMasks (self, dataRef)
def	setBrightObjectMasks (self, exposure, brightObjectMasks, dataId=None)
def	setInexactPsf (self, mask)
def	filterWarps (self, inputs, goodVisits)
def	countMaskFromFootprint (mask, footprint, bitmask, ignoreMask)

Variables
	log = logging.getLogger(__name__)
	id
	KEY
	patch
	tract
	filter
	visit
	ccd
	skyInfo
	calExpRefList
	warpRefList
	inputData
	supplementaryData
	retStruct
	brightObjects
	coaddDatasetName
	warpType

Function Documentation

applyAltMaskPlanes()

def lsst.pipe.tasks.assembleCoadd.applyAltMaskPlanes	(		self,
			mask,
			altMaskSpans
	)

Apply in place alt mask formatted as SpanSets to a mask.

Parameters
----------
mask : `lsst.afw.image.Mask`
    Original mask.
altMaskSpans : `dict`
    SpanSet lists to apply. Each element contains the new mask
    plane name (e.g. "CLIPPED and/or "NO_DATA") as the key,
    and list of SpanSets to apply to the mask.

Returns
-------
mask : `lsst.afw.image.Mask`
    Updated mask.

Definition at line 1136 of file assembleCoadd.py.

    def applyAltMaskPlanes(self, mask, altMaskSpans):
        """Apply in place alt mask formatted as SpanSets to a mask.
 
        Parameters
        ----------
        mask : `lsst.afw.image.Mask`
            Original mask.
        altMaskSpans : `dict`
            SpanSet lists to apply. Each element contains the new mask
            plane name (e.g. "CLIPPED and/or "NO_DATA") as the key,
            and list of SpanSets to apply to the mask.
 
        Returns
        -------
        mask : `lsst.afw.image.Mask`
            Updated mask.
        """
        if self.config.doUsePsfMatchedPolygons:
            if ("NO_DATA" in altMaskSpans) and ("NO_DATA" in self.config.badMaskPlanes):
                # Clear away any other masks outside the validPolygons. These pixels are no longer
                # contributing to inexact PSFs, and will still be rejected because of NO_DATA
                # self.config.doUsePsfMatchedPolygons should be True only in CompareWarpAssemble
                # This mask-clearing step must only occur *before* applying the new masks below
                for spanSet in altMaskSpans['NO_DATA']:
                    spanSet.clippedTo(mask.getBBox()).clearMask(mask, self.getBadPixelMask())
 
        for plane, spanSetList in altMaskSpans.items():
            maskClipValue = mask.addMaskPlane(plane)
            for spanSet in spanSetList:
                spanSet.clippedTo(mask.getBBox()).setMask(mask, 2**maskClipValue)
        return mask
 

assembleMetadata()

def lsst.pipe.tasks.assembleCoadd.assembleMetadata	(		self,
			coaddExposure,
			tempExpRefList,
			weightList
	)

Set the metadata for the coadd.

This basic implementation sets the filter from the first input.

Parameters
----------
coaddExposure : `lsst.afw.image.Exposure`
    The target exposure for the coadd.
tempExpRefList : `list`
    List of data references to tempExp.
weightList : `list`
    List of weights.

Definition at line 869 of file assembleCoadd.py.

    def assembleMetadata(self, coaddExposure, tempExpRefList, weightList):
        """Set the metadata for the coadd.
 
        This basic implementation sets the filter from the first input.
 
        Parameters
        ----------
        coaddExposure : `lsst.afw.image.Exposure`
            The target exposure for the coadd.
        tempExpRefList : `list`
            List of data references to tempExp.
        weightList : `list`
            List of weights.
        """
        assert len(tempExpRefList) == len(weightList), "Length mismatch"
        tempExpName = self.getTempExpDatasetName(self.warpType)
        # We load a single pixel of each coaddTempExp, because we just want to get at the metadata
        # (and we need more than just the PropertySet that contains the header), which is not possible
        # with the current butler (see #2777).
        bbox = geom.Box2I(coaddExposure.getBBox().getMin(), geom.Extent2I(1, 1))
 
        if isinstance(tempExpRefList[0], DeferredDatasetHandle):
            # Gen 3 API
            tempExpList = [tempExpRef.get(parameters={'bbox': bbox}) for tempExpRef in tempExpRefList]
        else:
            # Gen 2 API. Delete this when Gen 2 retired
            tempExpList = [tempExpRef.get(tempExpName + "_sub", bbox=bbox, immediate=True)
                           for tempExpRef in tempExpRefList]
        numCcds = sum(len(tempExp.getInfo().getCoaddInputs().ccds) for tempExp in tempExpList)
 
        # Set the coadd FilterLabel to the band of the first input exposure:
        # Coadds are calibrated, so the physical label is now meaningless.
        coaddExposure.setFilter(afwImage.FilterLabel(tempExpList[0].getFilter().bandLabel))
        coaddInputs = coaddExposure.getInfo().getCoaddInputs()
        coaddInputs.ccds.reserve(numCcds)
        coaddInputs.visits.reserve(len(tempExpList))
 
        for tempExp, weight in zip(tempExpList, weightList):
            self.inputRecorder.addVisitToCoadd(coaddInputs, tempExp, weight)
 
        if self.config.doUsePsfMatchedPolygons:
            self.shrinkValidPolygons(coaddInputs)
 
        coaddInputs.visits.sort()
        coaddInputs.ccds.sort()
        if self.warpType == "psfMatched":
            # The modelPsf BBox for a psfMatchedWarp/coaddTempExp was dynamically defined by
            # ModelPsfMatchTask as the square box bounding its spatially-variable, pre-matched WarpedPsf.
            # Likewise, set the PSF of a PSF-Matched Coadd to the modelPsf
            # having the maximum width (sufficient because square)
            modelPsfList = [tempExp.getPsf() for tempExp in tempExpList]
            modelPsfWidthList = [modelPsf.computeBBox(modelPsf.getAveragePosition()).getWidth()
                                 for modelPsf in modelPsfList]
            psf = modelPsfList[modelPsfWidthList.index(max(modelPsfWidthList))]
        else:
            psf = measAlg.CoaddPsf(coaddInputs.ccds, coaddExposure.getWcs(),
                                   self.config.coaddPsf.makeControl())
        coaddExposure.setPsf(psf)
        apCorrMap = measAlg.makeCoaddApCorrMap(coaddInputs.ccds, coaddExposure.getBBox(afwImage.PARENT),
                                               coaddExposure.getWcs())
        coaddExposure.getInfo().setApCorrMap(apCorrMap)
        if self.config.doAttachTransmissionCurve:
            transmissionCurve = measAlg.makeCoaddTransmissionCurve(coaddExposure.getWcs(), coaddInputs.ccds)
            coaddExposure.getInfo().setTransmissionCurve(transmissionCurve)
 

assembleOnlineMeanCoadd()

def lsst.pipe.tasks.assembleCoadd.assembleOnlineMeanCoadd	(		self,
			coaddExposure,
			tempExpRefList,
			imageScalerList,
			weightList,
			altMaskList,
			statsCtrl,
			nImage = None
	)

Assemble the coadd using the "online" method.

This method takes a running sum of images and weights to save memory.
It only works for MEAN statistics.

Parameters
----------
coaddExposure : `lsst.afw.image.Exposure`
    The target exposure for the coadd.
tempExpRefList : `list`
    List of data reference to tempExp.
imageScalerList : `list`
    List of image scalers.
weightList : `list`
    List of weights.
altMaskList : `list`
    List of alternate masks to use rather than those stored with
    tempExp, or None.  Each element is dict with keys = mask plane
    name to which to add the spans.
statsCtrl : `lsst.afw.math.StatisticsControl`
    Statistics control object for coadd
nImage : `lsst.afw.image.ImageU`, optional
    Keeps track of exposure count for each pixel.

Definition at line 1015 of file assembleCoadd.py.

                                altMaskList, statsCtrl, nImage=None):
        """Assemble the coadd using the "online" method.
 
        This method takes a running sum of images and weights to save memory.
        It only works for MEAN statistics.
 
        Parameters
        ----------
        coaddExposure : `lsst.afw.image.Exposure`
            The target exposure for the coadd.
        tempExpRefList : `list`
            List of data reference to tempExp.
        imageScalerList : `list`
            List of image scalers.
        weightList : `list`
            List of weights.
        altMaskList : `list`
            List of alternate masks to use rather than those stored with
            tempExp, or None.  Each element is dict with keys = mask plane
            name to which to add the spans.
        statsCtrl : `lsst.afw.math.StatisticsControl`
            Statistics control object for coadd
        nImage : `lsst.afw.image.ImageU`, optional
            Keeps track of exposure count for each pixel.
        """
        self.log.debug("Computing online coadd.")
        tempExpName = self.getTempExpDatasetName(self.warpType)
        coaddExposure.mask.addMaskPlane("REJECTED")
        coaddExposure.mask.addMaskPlane("CLIPPED")
        coaddExposure.mask.addMaskPlane("SENSOR_EDGE")
        maskMap = self.setRejectedMaskMapping(statsCtrl)
        thresholdDict = AccumulatorMeanStack.stats_ctrl_to_threshold_dict(statsCtrl)
 
        bbox = coaddExposure.maskedImage.getBBox()
 
        stacker = AccumulatorMeanStack(
            coaddExposure.image.array.shape,
            statsCtrl.getAndMask(),
            mask_threshold_dict=thresholdDict,
            mask_map=maskMap,
            no_good_pixels_mask=statsCtrl.getNoGoodPixelsMask(),
            calc_error_from_input_variance=self.config.calcErrorFromInputVariance,
            compute_n_image=(nImage is not None)
        )
 
        for tempExpRef, imageScaler, altMask, weight in zip(tempExpRefList,
                                                            imageScalerList,
                                                            altMaskList,
                                                            weightList):
            if isinstance(tempExpRef, DeferredDatasetHandle):
                # Gen 3 API
                exposure = tempExpRef.get()
            else:
                # Gen 2 API. Delete this when Gen 2 retired
                exposure = tempExpRef.get(tempExpName)
 
            maskedImage = exposure.getMaskedImage()
            mask = maskedImage.getMask()
            if altMask is not None:
                self.applyAltMaskPlanes(mask, altMask)
            imageScaler.scaleMaskedImage(maskedImage)
            if self.config.removeMaskPlanes:
                self.removeMaskPlanes(maskedImage)
 
            stacker.add_masked_image(maskedImage, weight=weight)
 
            if self.config.doInputMap:
                visit = exposure.getInfo().getCoaddInputs().visits[0].getId()
                self.inputMapper.mask_warp_bbox(bbox, visit, mask, statsCtrl.getAndMask())
 
        stacker.fill_stacked_masked_image(coaddExposure.maskedImage)
 
        if nImage is not None:
            nImage.array[:, :] = stacker.n_image
 

assembleSubregion()

def lsst.pipe.tasks.assembleCoadd.assembleSubregion	(		self,
			coaddExposure,
			bbox,
			tempExpRefList,
			imageScalerList,
			weightList,
			altMaskList,
			statsFlags,
			statsCtrl,
			nImage = None
	)

Assemble the coadd for a sub-region.

For each coaddTempExp, check for (and swap in) an alternative mask
if one is passed. Remove mask planes listed in
`config.removeMaskPlanes`. Finally, stack the actual exposures using
`lsst.afw.math.statisticsStack` with the statistic specified by
statsFlags. Typically, the statsFlag will be one of lsst.afw.math.MEAN for
a mean-stack or `lsst.afw.math.MEANCLIP` for outlier rejection using
an N-sigma clipped mean where N and iterations are specified by
statsCtrl.  Assign the stacked subregion back to the coadd.

Parameters
----------
coaddExposure : `lsst.afw.image.Exposure`
    The target exposure for the coadd.
bbox : `lsst.geom.Box`
    Sub-region to coadd.
tempExpRefList : `list`
    List of data reference to tempExp.
imageScalerList : `list`
    List of image scalers.
weightList : `list`
    List of weights.
altMaskList : `list`
    List of alternate masks to use rather than those stored with
    tempExp, or None.  Each element is dict with keys = mask plane
    name to which to add the spans.
statsFlags : `lsst.afw.math.Property`
    Property object for statistic for coadd.
statsCtrl : `lsst.afw.math.StatisticsControl`
    Statistics control object for coadd.
nImage : `lsst.afw.image.ImageU`, optional
    Keeps track of exposure count for each pixel.

Definition at line 934 of file assembleCoadd.py.

                          altMaskList, statsFlags, statsCtrl, nImage=None):
        """Assemble the coadd for a sub-region.
 
        For each coaddTempExp, check for (and swap in) an alternative mask
        if one is passed. Remove mask planes listed in
        `config.removeMaskPlanes`. Finally, stack the actual exposures using
        `lsst.afw.math.statisticsStack` with the statistic specified by
        statsFlags. Typically, the statsFlag will be one of lsst.afw.math.MEAN for
        a mean-stack or `lsst.afw.math.MEANCLIP` for outlier rejection using
        an N-sigma clipped mean where N and iterations are specified by
        statsCtrl.  Assign the stacked subregion back to the coadd.
 
        Parameters
        ----------
        coaddExposure : `lsst.afw.image.Exposure`
            The target exposure for the coadd.
        bbox : `lsst.geom.Box`
            Sub-region to coadd.
        tempExpRefList : `list`
            List of data reference to tempExp.
        imageScalerList : `list`
            List of image scalers.
        weightList : `list`
            List of weights.
        altMaskList : `list`
            List of alternate masks to use rather than those stored with
            tempExp, or None.  Each element is dict with keys = mask plane
            name to which to add the spans.
        statsFlags : `lsst.afw.math.Property`
            Property object for statistic for coadd.
        statsCtrl : `lsst.afw.math.StatisticsControl`
            Statistics control object for coadd.
        nImage : `lsst.afw.image.ImageU`, optional
            Keeps track of exposure count for each pixel.
        """
        self.log.debug("Computing coadd over %s", bbox)
        tempExpName = self.getTempExpDatasetName(self.warpType)
        coaddExposure.mask.addMaskPlane("REJECTED")
        coaddExposure.mask.addMaskPlane("CLIPPED")
        coaddExposure.mask.addMaskPlane("SENSOR_EDGE")
        maskMap = self.setRejectedMaskMapping(statsCtrl)
        clipped = afwImage.Mask.getPlaneBitMask("CLIPPED")
        maskedImageList = []
        if nImage is not None:
            subNImage = afwImage.ImageU(bbox.getWidth(), bbox.getHeight())
        for tempExpRef, imageScaler, altMask in zip(tempExpRefList, imageScalerList, altMaskList):
 
            if isinstance(tempExpRef, DeferredDatasetHandle):
                # Gen 3 API
                exposure = tempExpRef.get(parameters={'bbox': bbox})
            else:
                # Gen 2 API. Delete this when Gen 2 retired
                exposure = tempExpRef.get(tempExpName + "_sub", bbox=bbox)
 
            maskedImage = exposure.getMaskedImage()
            mask = maskedImage.getMask()
            if altMask is not None:
                self.applyAltMaskPlanes(mask, altMask)
            imageScaler.scaleMaskedImage(maskedImage)
 
            # Add 1 for each pixel which is not excluded by the exclude mask.
            # In legacyCoadd, pixels may also be excluded by afwMath.statisticsStack.
            if nImage is not None:
                subNImage.getArray()[maskedImage.getMask().getArray() & statsCtrl.getAndMask() == 0] += 1
            if self.config.removeMaskPlanes:
                self.removeMaskPlanes(maskedImage)
            maskedImageList.append(maskedImage)
 
            if self.config.doInputMap:
                visit = exposure.getInfo().getCoaddInputs().visits[0].getId()
                self.inputMapper.mask_warp_bbox(bbox, visit, mask, statsCtrl.getAndMask())
 
        with self.timer("stack"):
            coaddSubregion = afwMath.statisticsStack(maskedImageList, statsFlags, statsCtrl, weightList,
                                                     clipped,  # also set output to CLIPPED if sigma-clipped
                                                     maskMap)
        coaddExposure.maskedImage.assign(coaddSubregion, bbox)
        if nImage is not None:
            nImage.assign(subNImage, bbox)
 

countMaskFromFootprint()

def lsst.pipe.tasks.assembleCoadd.countMaskFromFootprint	(		mask,
			footprint,
			bitmask,
			ignoreMask
	)

Function to count the number of pixels with a specific mask in a
footprint.

Find the intersection of mask & footprint. Count all pixels in the mask
that are in the intersection that have bitmask set but do not have
ignoreMask set. Return the count.

Parameters
----------
mask : `lsst.afw.image.Mask`
    Mask to define intersection region by.
footprint : `lsst.afw.detection.Footprint`
    Footprint to define the intersection region by.
bitmask
    Specific mask that we wish to count the number of occurances of.
ignoreMask
    Pixels to not consider.

Returns
-------
result : `int`
    Count of number of pixels in footprint with specified mask.

Definition at line 1372 of file assembleCoadd.py.

def countMaskFromFootprint(mask, footprint, bitmask, ignoreMask):
    """Function to count the number of pixels with a specific mask in a
    footprint.
 
    Find the intersection of mask & footprint. Count all pixels in the mask
    that are in the intersection that have bitmask set but do not have
    ignoreMask set. Return the count.
 
    Parameters
    ----------
    mask : `lsst.afw.image.Mask`
        Mask to define intersection region by.
    footprint : `lsst.afw.detection.Footprint`
        Footprint to define the intersection region by.
    bitmask
        Specific mask that we wish to count the number of occurances of.
    ignoreMask
        Pixels to not consider.
 
    Returns
    -------
    result : `int`
        Count of number of pixels in footprint with specified mask.
    """
    bbox = footprint.getBBox()
    bbox.clip(mask.getBBox(afwImage.PARENT))
    fp = afwImage.Mask(bbox)
    subMask = mask.Factory(mask, bbox, afwImage.PARENT)
    footprint.spans.setMask(fp, bitmask)
    return numpy.logical_and((subMask.getArray() & fp.getArray()) > 0,
                             (subMask.getArray() & ignoreMask) == 0).sum()
 
 

filterWarps()

def lsst.pipe.tasks.assembleCoadd.filterWarps	(		self,
			inputs,
			goodVisits
	)

Return list of only inputRefs with visitId in goodVisits ordered by goodVisit

Parameters
----------
inputs : list
    List of `lsst.pipe.base.connections.DeferredDatasetRef` with dataId containing visit
goodVisit : `dict`
    Dictionary with good visitIds as the keys. Value ignored.

Returns:
--------
filteredInputs : `list`
    Filtered and sorted list of `lsst.pipe.base.connections.DeferredDatasetRef`

Definition at line 1321 of file assembleCoadd.py.

    def filterWarps(self, inputs, goodVisits):
        """Return list of only inputRefs with visitId in goodVisits ordered by goodVisit
 
        Parameters
        ----------
        inputs : list
            List of `lsst.pipe.base.connections.DeferredDatasetRef` with dataId containing visit
        goodVisit : `dict`
            Dictionary with good visitIds as the keys. Value ignored.
 
        Returns:
        --------
        filteredInputs : `list`
            Filtered and sorted list of `lsst.pipe.base.connections.DeferredDatasetRef`
        """
        inputWarpDict = {inputRef.ref.dataId['visit']: inputRef for inputRef in inputs}
        filteredInputs = []
        for visit in goodVisits.keys():
            if visit in inputWarpDict:
                filteredInputs.append(inputWarpDict[visit])
        return filteredInputs
 
 

getTempExpRefList()

def lsst.pipe.tasks.assembleCoadd.getTempExpRefList	(		self,
			patchRef,
			calExpRefList
	)

Generate list data references corresponding to warped exposures
that lie within the patch to be coadded.

Parameters
----------
patchRef : `dataRef`
    Data reference for patch.
calExpRefList : `list`
    List of data references for input calexps.

Returns
-------
tempExpRefList : `list`
    List of Warp/CoaddTempExp data references.

Definition at line 631 of file assembleCoadd.py.

    def getTempExpRefList(self, patchRef, calExpRefList):
        """Generate list data references corresponding to warped exposures
        that lie within the patch to be coadded.
 
        Parameters
        ----------
        patchRef : `dataRef`
            Data reference for patch.
        calExpRefList : `list`
            List of data references for input calexps.
 
        Returns
        -------
        tempExpRefList : `list`
            List of Warp/CoaddTempExp data references.
        """
        butler = patchRef.getButler()
        groupData = groupPatchExposures(patchRef, calExpRefList, self.getCoaddDatasetName(self.warpType),
                                        self.getTempExpDatasetName(self.warpType))
        tempExpRefList = [getGroupDataRef(butler, self.getTempExpDatasetName(self.warpType),
                                          g, groupData.keys) for
                          g in groupData.groups.keys()]
        return tempExpRefList
 

makeSupplementaryData()

def lsst.pipe.tasks.assembleCoadd.makeSupplementaryData	(		self,
			dataRef,
			selectDataList = None,
			warpRefList = None
	)

Make additional inputs to run() specific to subclasses (Gen2)

Duplicates interface of `runDataRef` method
Available to be implemented by subclasses only if they need the
coadd dataRef for performing preliminary processing before
assembling the coadd.

Parameters
----------
dataRef : `lsst.daf.persistence.ButlerDataRef`
    Butler data reference for supplementary data.
selectDataList : `list` (optional)
    Optional List of data references to Calexps.
warpRefList : `list` (optional)
    Optional List of data references to Warps.

Definition at line 588 of file assembleCoadd.py.

    def makeSupplementaryData(self, dataRef, selectDataList=None, warpRefList=None):
        """Make additional inputs to run() specific to subclasses (Gen2)
 
        Duplicates interface of `runDataRef` method
        Available to be implemented by subclasses only if they need the
        coadd dataRef for performing preliminary processing before
        assembling the coadd.
 
        Parameters
        ----------
        dataRef : `lsst.daf.persistence.ButlerDataRef`
            Butler data reference for supplementary data.
        selectDataList : `list` (optional)
            Optional List of data references to Calexps.
        warpRefList : `list` (optional)
            Optional List of data references to Warps.
        """
        return pipeBase.Struct()
 

makeSupplementaryDataGen3()

def lsst.pipe.tasks.assembleCoadd.makeSupplementaryDataGen3	(		self,
			butlerQC,
			inputRefs,
			outputRefs
	)

Make additional inputs to run() specific to subclasses (Gen3)

Duplicates interface of `runQuantum` method.
Available to be implemented by subclasses only if they need the
coadd dataRef for performing preliminary processing before
assembling the coadd.

Parameters
----------
butlerQC : `lsst.pipe.base.ButlerQuantumContext`
    Gen3 Butler object for fetching additional data products before
    running the Task specialized for quantum being processed
inputRefs : `lsst.pipe.base.InputQuantizedConnection`
    Attributes are the names of the connections describing input dataset types.
    Values are DatasetRefs that task consumes for corresponding dataset type.
    DataIds are guaranteed to match data objects in ``inputData``.
outputRefs : `lsst.pipe.base.OutputQuantizedConnection`
    Attributes are the names of the connections describing output dataset types.
    Values are DatasetRefs that task is to produce
    for corresponding dataset type.

Definition at line 607 of file assembleCoadd.py.

    def makeSupplementaryDataGen3(self, butlerQC, inputRefs, outputRefs):
        """Make additional inputs to run() specific to subclasses (Gen3)
 
        Duplicates interface of `runQuantum` method.
        Available to be implemented by subclasses only if they need the
        coadd dataRef for performing preliminary processing before
        assembling the coadd.
 
        Parameters
        ----------
        butlerQC : `lsst.pipe.base.ButlerQuantumContext`
            Gen3 Butler object for fetching additional data products before
            running the Task specialized for quantum being processed
        inputRefs : `lsst.pipe.base.InputQuantizedConnection`
            Attributes are the names of the connections describing input dataset types.
            Values are DatasetRefs that task consumes for corresponding dataset type.
            DataIds are guaranteed to match data objects in ``inputData``.
        outputRefs : `lsst.pipe.base.OutputQuantizedConnection`
            Attributes are the names of the connections describing output dataset types.
            Values are DatasetRefs that task is to produce
            for corresponding dataset type.
        """
        return pipeBase.Struct()
 

prepareInputs()

def lsst.pipe.tasks.assembleCoadd.prepareInputs	(		self,
			refList
	)

Prepare the input warps for coaddition by measuring the weight for
each warp and the scaling for the photometric zero point.

Each Warp has its own photometric zeropoint and background variance.
Before coadding these Warps together, compute a scale factor to
normalize the photometric zeropoint and compute the weight for each Warp.

Parameters
----------
refList : `list`
    List of data references to tempExp

Returns
-------
result : `lsst.pipe.base.Struct`
   Result struct with components:

   - ``tempExprefList``: `list` of data references to tempExp.
   - ``weightList``: `list` of weightings.
   - ``imageScalerList``: `list` of image scalers.

Definition at line 655 of file assembleCoadd.py.

    def prepareInputs(self, refList):
        """Prepare the input warps for coaddition by measuring the weight for
        each warp and the scaling for the photometric zero point.
 
        Each Warp has its own photometric zeropoint and background variance.
        Before coadding these Warps together, compute a scale factor to
        normalize the photometric zeropoint and compute the weight for each Warp.
 
        Parameters
        ----------
        refList : `list`
            List of data references to tempExp
 
        Returns
        -------
        result : `lsst.pipe.base.Struct`
           Result struct with components:
 
           - ``tempExprefList``: `list` of data references to tempExp.
           - ``weightList``: `list` of weightings.
           - ``imageScalerList``: `list` of image scalers.
        """
        statsCtrl = afwMath.StatisticsControl()
        statsCtrl.setNumSigmaClip(self.config.sigmaClip)
        statsCtrl.setNumIter(self.config.clipIter)
        statsCtrl.setAndMask(self.getBadPixelMask())
        statsCtrl.setNanSafe(True)
        # compute tempExpRefList: a list of tempExpRef that actually exist
        # and weightList: a list of the weight of the associated coadd tempExp
        # and imageScalerList: a list of scale factors for the associated coadd tempExp
        tempExpRefList = []
        weightList = []
        imageScalerList = []
        tempExpName = self.getTempExpDatasetName(self.warpType)
        for tempExpRef in refList:
            # Gen3's DeferredDatasetHandles are guaranteed to exist and
            # therefore have no datasetExists() method
            if not isinstance(tempExpRef, DeferredDatasetHandle):
                if not tempExpRef.datasetExists(tempExpName):
                    self.log.warning("Could not find %s %s; skipping it", tempExpName, tempExpRef.dataId)
                    continue
 
            tempExp = tempExpRef.get(datasetType=tempExpName, immediate=True)
            # Ignore any input warp that is empty of data
            if numpy.isnan(tempExp.image.array).all():
                continue
            maskedImage = tempExp.getMaskedImage()
            imageScaler = self.scaleZeroPoint.computeImageScaler(
                exposure=tempExp,
                dataRef=tempExpRef,
            )
            try:
                imageScaler.scaleMaskedImage(maskedImage)
            except Exception as e:
                self.log.warning("Scaling failed for %s (skipping it): %s", tempExpRef.dataId, e)
                continue
            statObj = afwMath.makeStatistics(maskedImage.getVariance(), maskedImage.getMask(),
                                             afwMath.MEANCLIP, statsCtrl)
            meanVar, meanVarErr = statObj.getResult(afwMath.MEANCLIP)
            weight = 1.0 / float(meanVar)
            if not numpy.isfinite(weight):
                self.log.warning("Non-finite weight for %s: skipping", tempExpRef.dataId)
                continue
            self.log.info("Weight of %s %s = %0.3f", tempExpName, tempExpRef.dataId, weight)
 
            del maskedImage
            del tempExp
 
            tempExpRefList.append(tempExpRef)
            weightList.append(weight)
            imageScalerList.append(imageScaler)
 
        return pipeBase.Struct(tempExpRefList=tempExpRefList, weightList=weightList,
                               imageScalerList=imageScalerList)
 

prepareStats()

def lsst.pipe.tasks.assembleCoadd.prepareStats	(		self,
			mask = None
	)

Prepare the statistics for coadding images.

Parameters
----------
mask : `int`, optional
    Bit mask value to exclude from coaddition.

Returns
-------
stats : `lsst.pipe.base.Struct`
    Statistics structure with the following fields:

    - ``statsCtrl``: Statistics control object for coadd
        (`lsst.afw.math.StatisticsControl`)
    - ``statsFlags``: Statistic for coadd (`lsst.afw.math.Property`)

Definition at line 730 of file assembleCoadd.py.

    def prepareStats(self, mask=None):
        """Prepare the statistics for coadding images.
 
        Parameters
        ----------
        mask : `int`, optional
            Bit mask value to exclude from coaddition.
 
        Returns
        -------
        stats : `lsst.pipe.base.Struct`
            Statistics structure with the following fields:
 
            - ``statsCtrl``: Statistics control object for coadd
                (`lsst.afw.math.StatisticsControl`)
            - ``statsFlags``: Statistic for coadd (`lsst.afw.math.Property`)
        """
        if mask is None:
            mask = self.getBadPixelMask()
        statsCtrl = afwMath.StatisticsControl()
        statsCtrl.setNumSigmaClip(self.config.sigmaClip)
        statsCtrl.setNumIter(self.config.clipIter)
        statsCtrl.setAndMask(mask)
        statsCtrl.setNanSafe(True)
        statsCtrl.setWeighted(True)
        statsCtrl.setCalcErrorFromInputVariance(self.config.calcErrorFromInputVariance)
        for plane, threshold in self.config.maskPropagationThresholds.items():
            bit = afwImage.Mask.getMaskPlane(plane)
            statsCtrl.setMaskPropagationThreshold(bit, threshold)
        statsFlags = afwMath.stringToStatisticsProperty(self.config.statistic)
        return pipeBase.Struct(ctrl=statsCtrl, flags=statsFlags)
 

processResults()

def lsst.pipe.tasks.assembleCoadd.processResults	(		self,
			coaddExposure,
			brightObjectMasks = None,
			dataId = None
	)

Interpolate over missing data and mask bright stars.

Parameters
----------
coaddExposure : `lsst.afw.image.Exposure`
    The coadded exposure to process.
dataRef : `lsst.daf.persistence.ButlerDataRef`
    Butler data reference for supplementary data.

Definition at line 568 of file assembleCoadd.py.

    def processResults(self, coaddExposure, brightObjectMasks=None, dataId=None):
        """Interpolate over missing data and mask bright stars.
 
        Parameters
        ----------
        coaddExposure : `lsst.afw.image.Exposure`
            The coadded exposure to process.
        dataRef : `lsst.daf.persistence.ButlerDataRef`
            Butler data reference for supplementary data.
        """
        if self.config.doInterp:
            self.interpImage.run(coaddExposure.getMaskedImage(), planeName="NO_DATA")
            # The variance must be positive; work around for DM-3201.
            varArray = coaddExposure.variance.array
            with numpy.errstate(invalid="ignore"):
                varArray[:] = numpy.where(varArray > 0, varArray, numpy.inf)
 
        if self.config.doMaskBrightObjects:
            self.setBrightObjectMasks(coaddExposure, brightObjectMasks, dataId)
 

readBrightObjectMasks()

def lsst.pipe.tasks.assembleCoadd.readBrightObjectMasks	(		self,
			dataRef
	)

Retrieve the bright object masks.

Returns None on failure.

Parameters
----------
dataRef : `lsst.daf.persistence.butlerSubset.ButlerDataRef`
    A Butler dataRef.

Returns
-------
result : `lsst.daf.persistence.butlerSubset.ButlerDataRef`
    Bright object mask from the Butler object, or None if it cannot
    be retrieved.

Definition at line 1190 of file assembleCoadd.py.

    def readBrightObjectMasks(self, dataRef):
        """Retrieve the bright object masks.
 
        Returns None on failure.
 
        Parameters
        ----------
        dataRef : `lsst.daf.persistence.butlerSubset.ButlerDataRef`
            A Butler dataRef.
 
        Returns
        -------
        result : `lsst.daf.persistence.butlerSubset.ButlerDataRef`
            Bright object mask from the Butler object, or None if it cannot
            be retrieved.
        """
        try:
            return dataRef.get(datasetType="brightObjectMask", immediate=True)
        except Exception as e:
            self.log.warning("Unable to read brightObjectMask for %s: %s", dataRef.dataId, e)
            return None
 

removeMaskPlanes()

def lsst.pipe.tasks.assembleCoadd.removeMaskPlanes	(		self,
			maskedImage
	)

Unset the mask of an image for mask planes specified in the config.

Parameters
----------
maskedImage : `lsst.afw.image.MaskedImage`
    The masked image to be modified.

Definition at line 1091 of file assembleCoadd.py.

    def removeMaskPlanes(self, maskedImage):
        """Unset the mask of an image for mask planes specified in the config.
 
        Parameters
        ----------
        maskedImage : `lsst.afw.image.MaskedImage`
            The masked image to be modified.
        """
        mask = maskedImage.getMask()
        for maskPlane in self.config.removeMaskPlanes:
            try:
                mask &= ~mask.getPlaneBitMask(maskPlane)
            except pexExceptions.InvalidParameterError:
                self.log.debug("Unable to remove mask plane %s: no mask plane with that name was found.",
                               maskPlane)
 

run()

def lsst.pipe.tasks.assembleCoadd.run	(		self,
			skyInfo,
			tempExpRefList,
			imageScalerList,
			weightList,
			altMaskList = None,
			mask = None,
			supplementaryData = None
	)

Assemble a coadd from input warps

Assemble the coadd using the provided list of coaddTempExps. Since
the full coadd covers a patch (a large area), the assembly is
performed over small areas on the image at a time in order to
conserve memory usage. Iterate over subregions within the outer
bbox of the patch using `assembleSubregion` to stack the corresponding
subregions from the coaddTempExps with the statistic specified.
Set the edge bits the coadd mask based on the weight map.

Parameters
----------
skyInfo : `lsst.pipe.base.Struct`
    Struct with geometric information about the patch.
tempExpRefList : `list`
    List of data references to Warps (previously called CoaddTempExps).
imageScalerList : `list`
    List of image scalers.
weightList : `list`
    List of weights
altMaskList : `list`, optional
    List of alternate masks to use rather than those stored with
    tempExp.
mask : `int`, optional
    Bit mask value to exclude from coaddition.
supplementaryData : lsst.pipe.base.Struct, optional
    Struct with additional data products needed to assemble coadd.
    Only used by subclasses that implement `makeSupplementaryData`
    and override `run`.

Returns
-------
result : `lsst.pipe.base.Struct`
   Result struct with components:

   - ``coaddExposure``: coadded exposure (``lsst.afw.image.Exposure``).
   - ``nImage``: exposure count image (``lsst.afw.image.Image``), if requested.
   - ``inputMap``: bit-wise map of inputs, if requested.
   - ``warpRefList``: input list of refs to the warps (
                      ``lsst.daf.butler.DeferredDatasetHandle`` or
                      ``lsst.daf.persistence.ButlerDataRef``)
                      (unmodified)
   - ``imageScalerList``: input list of image scalers (unmodified)
   - ``weightList``: input list of weights (unmodified)

Definition at line 763 of file assembleCoadd.py.

            altMaskList=None, mask=None, supplementaryData=None):
        """Assemble a coadd from input warps
 
        Assemble the coadd using the provided list of coaddTempExps. Since
        the full coadd covers a patch (a large area), the assembly is
        performed over small areas on the image at a time in order to
        conserve memory usage. Iterate over subregions within the outer
        bbox of the patch using `assembleSubregion` to stack the corresponding
        subregions from the coaddTempExps with the statistic specified.
        Set the edge bits the coadd mask based on the weight map.
 
        Parameters
        ----------
        skyInfo : `lsst.pipe.base.Struct`
            Struct with geometric information about the patch.
        tempExpRefList : `list`
            List of data references to Warps (previously called CoaddTempExps).
        imageScalerList : `list`
            List of image scalers.
        weightList : `list`
            List of weights
        altMaskList : `list`, optional
            List of alternate masks to use rather than those stored with
            tempExp.
        mask : `int`, optional
            Bit mask value to exclude from coaddition.
        supplementaryData : lsst.pipe.base.Struct, optional
            Struct with additional data products needed to assemble coadd.
            Only used by subclasses that implement `makeSupplementaryData`
            and override `run`.
 
        Returns
        -------
        result : `lsst.pipe.base.Struct`
           Result struct with components:
 
           - ``coaddExposure``: coadded exposure (``lsst.afw.image.Exposure``).
           - ``nImage``: exposure count image (``lsst.afw.image.Image``), if requested.
           - ``inputMap``: bit-wise map of inputs, if requested.
           - ``warpRefList``: input list of refs to the warps (
                              ``lsst.daf.butler.DeferredDatasetHandle`` or
                              ``lsst.daf.persistence.ButlerDataRef``)
                              (unmodified)
           - ``imageScalerList``: input list of image scalers (unmodified)
           - ``weightList``: input list of weights (unmodified)
        """
        tempExpName = self.getTempExpDatasetName(self.warpType)
        self.log.info("Assembling %s %s", len(tempExpRefList), tempExpName)
        stats = self.prepareStats(mask=mask)
 
        if altMaskList is None:
            altMaskList = [None]*len(tempExpRefList)
 
        coaddExposure = afwImage.ExposureF(skyInfo.bbox, skyInfo.wcs)
        coaddExposure.setPhotoCalib(self.scaleZeroPoint.getPhotoCalib())
        coaddExposure.getInfo().setCoaddInputs(self.inputRecorder.makeCoaddInputs())
        self.assembleMetadata(coaddExposure, tempExpRefList, weightList)
        coaddMaskedImage = coaddExposure.getMaskedImage()
        subregionSizeArr = self.config.subregionSize
        subregionSize = geom.Extent2I(subregionSizeArr[0], subregionSizeArr[1])
        # if nImage is requested, create a zero one which can be passed to assembleSubregion
        if self.config.doNImage:
            nImage = afwImage.ImageU(skyInfo.bbox)
        else:
            nImage = None
        # If inputMap is requested, create the initial version that can be masked in
        # assembleSubregion.
        if self.config.doInputMap:
            self.inputMapper.build_ccd_input_map(skyInfo.bbox,
                                                 skyInfo.wcs,
                                                 coaddExposure.getInfo().getCoaddInputs().ccds)
 
        if self.config.doOnlineForMean and self.config.statistic == "MEAN":
            try:
                self.assembleOnlineMeanCoadd(coaddExposure, tempExpRefList, imageScalerList,
                                             weightList, altMaskList, stats.ctrl,
                                             nImage=nImage)
            except Exception as e:
                self.log.exception("Cannot compute online coadd %s", e)
                raise
        else:
            for subBBox in self._subBBoxIter(skyInfo.bbox, subregionSize):
                try:
                    self.assembleSubregion(coaddExposure, subBBox, tempExpRefList, imageScalerList,
                                           weightList, altMaskList, stats.flags, stats.ctrl,
                                           nImage=nImage)
                except Exception as e:
                    self.log.exception("Cannot compute coadd %s: %s", subBBox, e)
                    raise
 
        # If inputMap is requested, we must finalize the map after the accumulation.
        if self.config.doInputMap:
            self.inputMapper.finalize_ccd_input_map_mask()
            inputMap = self.inputMapper.ccd_input_map
        else:
            inputMap = None
 
        self.setInexactPsf(coaddMaskedImage.getMask())
        # Despite the name, the following doesn't really deal with "EDGE" pixels: it identifies
        # pixels that didn't receive any unmasked inputs (as occurs around the edge of the field).
        coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(), coaddMaskedImage.getVariance())
        return pipeBase.Struct(coaddExposure=coaddExposure, nImage=nImage,
                               warpRefList=tempExpRefList, imageScalerList=imageScalerList,
                               weightList=weightList, inputMap=inputMap)
 

setBrightObjectMasks()

def lsst.pipe.tasks.assembleCoadd.setBrightObjectMasks	(		self,
			exposure,
			brightObjectMasks,
			dataId = None
	)

Set the bright object masks.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure under consideration.
dataId : `lsst.daf.persistence.dataId`
    Data identifier dict for patch.
brightObjectMasks : `lsst.afw.table`
    Table of bright objects to mask.

Definition at line 1212 of file assembleCoadd.py.

    def setBrightObjectMasks(self, exposure, brightObjectMasks, dataId=None):
        """Set the bright object masks.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure under consideration.
        dataId : `lsst.daf.persistence.dataId`
            Data identifier dict for patch.
        brightObjectMasks : `lsst.afw.table`
            Table of bright objects to mask.
        """
 
        if brightObjectMasks is None:
            self.log.warning("Unable to apply bright object mask: none supplied")
            return
        self.log.info("Applying %d bright object masks to %s", len(brightObjectMasks), dataId)
        mask = exposure.getMaskedImage().getMask()
        wcs = exposure.getWcs()
        plateScale = wcs.getPixelScale().asArcseconds()
 
        for rec in brightObjectMasks:
            center = geom.PointI(wcs.skyToPixel(rec.getCoord()))
            if rec["type"] == "box":
                assert rec["angle"] == 0.0, ("Angle != 0 for mask object %s" % rec["id"])
                width = rec["width"].asArcseconds()/plateScale    # convert to pixels
                height = rec["height"].asArcseconds()/plateScale  # convert to pixels
 
                halfSize = geom.ExtentI(0.5*width, 0.5*height)
                bbox = geom.Box2I(center - halfSize, center + halfSize)
 
                bbox = geom.BoxI(geom.PointI(int(center[0] - 0.5*width), int(center[1] - 0.5*height)),
                                 geom.PointI(int(center[0] + 0.5*width), int(center[1] + 0.5*height)))
                spans = afwGeom.SpanSet(bbox)
            elif rec["type"] == "circle":
                radius = int(rec["radius"].asArcseconds()/plateScale)   # convert to pixels
                spans = afwGeom.SpanSet.fromShape(radius, offset=center)
            else:
                self.log.warning("Unexpected region type %s at %s", rec["type"], center)
                continue
            spans.clippedTo(mask.getBBox()).setMask(mask, self.brightObjectBitmask)
 

setInexactPsf()

def lsst.pipe.tasks.assembleCoadd.setInexactPsf	(		self,
			mask
	)

Set INEXACT_PSF mask plane.

If any of the input images isn't represented in the coadd (due to
clipped pixels or chip gaps), the `CoaddPsf` will be inexact. Flag
these pixels.

Parameters
----------
mask : `lsst.afw.image.Mask`
    Coadded exposure's mask, modified in-place.

Definition at line 1254 of file assembleCoadd.py.

    def setInexactPsf(self, mask):
        """Set INEXACT_PSF mask plane.
 
        If any of the input images isn't represented in the coadd (due to
        clipped pixels or chip gaps), the `CoaddPsf` will be inexact. Flag
        these pixels.
 
        Parameters
        ----------
        mask : `lsst.afw.image.Mask`
            Coadded exposure's mask, modified in-place.
        """
        mask.addMaskPlane("INEXACT_PSF")
        inexactPsf = mask.getPlaneBitMask("INEXACT_PSF")
        sensorEdge = mask.getPlaneBitMask("SENSOR_EDGE")  # chip edges (so PSF is discontinuous)
        clipped = mask.getPlaneBitMask("CLIPPED")  # pixels clipped from coadd
        rejected = mask.getPlaneBitMask("REJECTED")  # pixels rejected from coadd due to masks
        array = mask.getArray()
        selected = array & (sensorEdge | clipped | rejected) > 0
        array[selected] |= inexactPsf
 

shrinkValidPolygons()

def lsst.pipe.tasks.assembleCoadd.shrinkValidPolygons	(		self,
			coaddInputs
	)

Shrink coaddInputs' ccds' ValidPolygons in place.

Either modify each ccd's validPolygon in place, or if CoaddInputs
does not have a validPolygon, create one from its bbox.

Parameters
----------
coaddInputs : `lsst.afw.image.coaddInputs`
    Original mask.

Definition at line 1168 of file assembleCoadd.py.

    def shrinkValidPolygons(self, coaddInputs):
        """Shrink coaddInputs' ccds' ValidPolygons in place.
 
        Either modify each ccd's validPolygon in place, or if CoaddInputs
        does not have a validPolygon, create one from its bbox.
 
        Parameters
        ----------
        coaddInputs : `lsst.afw.image.coaddInputs`
            Original mask.
 
        """
        for ccd in coaddInputs.ccds:
            polyOrig = ccd.getValidPolygon()
            validPolyBBox = polyOrig.getBBox() if polyOrig else ccd.getBBox()
            validPolyBBox.grow(-self.config.matchingKernelSize//2)
            if polyOrig:
                validPolygon = polyOrig.intersectionSingle(validPolyBBox)
            else:
                validPolygon = afwGeom.polygon.Polygon(geom.Box2D(validPolyBBox))
            ccd.setValidPolygon(validPolygon)
 

Variable Documentation

brightObjects

lsst.pipe.tasks.assembleCoadd.brightObjects

Definition at line 553 of file assembleCoadd.py.

calExpRefList

lsst.pipe.tasks.assembleCoadd.calExpRefList

Definition at line 533 of file assembleCoadd.py.

ccd

lsst.pipe.tasks.assembleCoadd.ccd

Definition at line 382 of file assembleCoadd.py.

coaddDatasetName

lsst.pipe.tasks.assembleCoadd.coaddDatasetName

Definition at line 558 of file assembleCoadd.py.

filter

lsst.pipe.tasks.assembleCoadd.filter

Definition at line 381 of file assembleCoadd.py.

id

lsst.pipe.tasks.assembleCoadd.id

warpType = pexConfig.Field(
    doc="Warp name: one of 'direct' or 'psfMatched'",
    dtype=str,
    default="direct",
)
subregionSize = pexConfig.ListField(
    dtype=int,
    doc="Width, height of stack subregion size; "
    "make small enough that a full stack of images will fit into memory at once.",
    length=2,
    default=(2000, 2000),
)
statistic = pexConfig.Field(
    dtype=str,
    doc="Main stacking statistic for aggregating over the epochs.",
    default="MEANCLIP",
)
doOnlineForMean = pexConfig.Field(
    dtype=bool,
    doc="Perform online coaddition when statistic=\"MEAN\" to save memory?",
    default=False,
)
doSigmaClip = pexConfig.Field(
    dtype=bool,
    doc="Perform sigma clipped outlier rejection with MEANCLIP statistic? (DEPRECATED)",
    default=False,
)
sigmaClip = pexConfig.Field(
    dtype=float,
    doc="Sigma for outlier rejection; ignored if non-clipping statistic selected.",
    default=3.0,
)
clipIter = pexConfig.Field(
    dtype=int,
    doc="Number of iterations of outlier rejection; ignored if non-clipping statistic selected.",
    default=2,
)
calcErrorFromInputVariance = pexConfig.Field(
    dtype=bool,
    doc="Calculate coadd variance from input variance by stacking statistic."
        "Passed to StatisticsControl.setCalcErrorFromInputVariance()",
    default=True,
)
scaleZeroPoint = pexConfig.ConfigurableField(
    target=ScaleZeroPointTask,
    doc="Task to adjust the photometric zero point of the coadd temp exposures",
)
doInterp = pexConfig.Field(
    doc="Interpolate over NaN pixels? Also extrapolate, if necessary, but the results are ugly.",
    dtype=bool,
    default=True,
)
interpImage = pexConfig.ConfigurableField(
    target=InterpImageTask,
    doc="Task to interpolate (and extrapolate) over NaN pixels",
)
doWrite = pexConfig.Field(
    doc="Persist coadd?",
    dtype=bool,
    default=True,
)
doNImage = pexConfig.Field(
    doc="Create image of number of contributing exposures for each pixel",
    dtype=bool,
    default=False,
)
doUsePsfMatchedPolygons = pexConfig.Field(
    doc="Use ValidPolygons from shrunk Psf-Matched Calexps? Should be set to True by CompareWarp only.",
    dtype=bool,
    default=False,
)
maskPropagationThresholds = pexConfig.DictField(
    keytype=str,
    itemtype=float,
    doc=("Threshold (in fractional weight) of rejection at which we propagate a mask plane to "
         "the coadd; that is, we set the mask bit on the coadd if the fraction the rejected frames "
         "would have contributed exceeds this value."),
    default={"SAT": 0.1},
)
removeMaskPlanes = pexConfig.ListField(dtype=str, default=["NOT_DEBLENDED"],
                                       doc="Mask planes to remove before coadding")
doMaskBrightObjects = pexConfig.Field(dtype=bool, default=False,
                                      doc="Set mask and flag bits for bright objects?")
brightObjectMaskName = pexConfig.Field(dtype=str, default="BRIGHT_OBJECT",
                                       doc="Name of mask bit used for bright objects")
coaddPsf = pexConfig.ConfigField(
    doc="Configuration for CoaddPsf",
    dtype=measAlg.CoaddPsfConfig,
)
doAttachTransmissionCurve = pexConfig.Field(
    dtype=bool, default=False, optional=False,
    doc=("Attach a piecewise TransmissionCurve for the coadd? "
         "(requires all input Exposures to have TransmissionCurves).")
)
hasFakes = pexConfig.Field(
    dtype=bool,
    default=False,
    doc="Should be set to True if fake sources have been inserted into the input data."
)
doSelectVisits = pexConfig.Field(
    doc="Coadd only visits selected by a SelectVisitsTask",
    dtype=bool,
    default=False,
)
doInputMap = pexConfig.Field(
    doc="Create a bitwise map of coadd inputs",
    dtype=bool,
    default=False,
)
inputMapper = pexConfig.ConfigurableField(
    doc="Input map creation subtask.",
    target=HealSparseInputMapTask,
)

def setDefaults(self):
    super().setDefaults()
    self.badMaskPlanes = ["NO_DATA", "BAD", "SAT", "EDGE"]

def validate(self):
    super().validate()
    if self.doPsfMatch:
        # Backwards compatibility.
        # Configs do not have loggers
        log.warning("Config doPsfMatch deprecated. Setting warpType='psfMatched'")
        self.warpType = 'psfMatched'
    if self.doSigmaClip and self.statistic != "MEANCLIP":
        log.warning('doSigmaClip deprecated. To replicate behavior, setting statistic to "MEANCLIP"')
        self.statistic = "MEANCLIP"
    if self.doInterp and self.statistic not in ['MEAN', 'MEDIAN', 'MEANCLIP', 'VARIANCE', 'VARIANCECLIP']:
        raise ValueError("Must set doInterp=False for statistic=%s, which does not "
                         "compute and set a non-zero coadd variance estimate." % (self.statistic))

    unstackableStats = ['NOTHING', 'ERROR', 'ORMASK']
    if not hasattr(afwMath.Property, self.statistic) or self.statistic in unstackableStats:
        stackableStats = [str(k) for k in afwMath.Property.__members__.keys()
                          if str(k) not in unstackableStats]
        raise ValueError("statistic %s is not allowed. Please choose one of %s."
                         % (self.statistic, stackableStats))


class AssembleCoaddTask(CoaddBaseTask, pipeBase.PipelineTask):

Definition at line 343 of file assembleCoadd.py.

inputData

lsst.pipe.tasks.assembleCoadd.inputData

Definition at line 541 of file assembleCoadd.py.

KEY

lsst.pipe.tasks.assembleCoadd.KEY

Definition at line 343 of file assembleCoadd.py.

log

lsst.pipe.tasks.assembleCoadd.log = logging.getLogger(__name__)

Definition at line 55 of file assembleCoadd.py.

patch

lsst.pipe.tasks.assembleCoadd.patch

Definition at line 381 of file assembleCoadd.py.

retStruct

lsst.pipe.tasks.assembleCoadd.retStruct

Definition at line 550 of file assembleCoadd.py.

skyInfo

lsst.pipe.tasks.assembleCoadd.skyInfo

ConfigClass = AssembleCoaddConfig
_DefaultName = "assembleCoadd"

def __init__(self, *args, **kwargs):
    # TODO: DM-17415 better way to handle previously allowed passed args e.g.`AssembleCoaddTask(config)`
    if args:
        argNames = ["config", "name", "parentTask", "log"]
        kwargs.update({k: v for k, v in zip(argNames, args)})
        warnings.warn("AssembleCoadd received positional args, and casting them as kwargs: %s. "
                      "PipelineTask will not take positional args" % argNames, FutureWarning)

    super().__init__(**kwargs)
    self.makeSubtask("interpImage")
    self.makeSubtask("scaleZeroPoint")

    if self.config.doMaskBrightObjects:
        mask = afwImage.Mask()
        try:
            self.brightObjectBitmask = 1 << mask.addMaskPlane(self.config.brightObjectMaskName)
        except pexExceptions.LsstCppException:
            raise RuntimeError("Unable to define mask plane for bright objects; planes used are %s" %
                               mask.getMaskPlaneDict().keys())
        del mask

    if self.config.doInputMap:
        self.makeSubtask("inputMapper")

    self.warpType = self.config.warpType

@utils.inheritDoc(pipeBase.PipelineTask)
def runQuantum(self, butlerQC, inputRefs, outputRefs):
    # Docstring to be formatted with info from PipelineTask.runQuantum

inputData = butlerQC.get(inputRefs)

# Construct skyInfo expected by run
# Do not remove skyMap from inputData in case makeSupplementaryDataGen3 needs it
skyMap = inputData["skyMap"]
outputDataId = butlerQC.quantum.dataId

inputData['skyInfo'] = makeSkyInfo(skyMap,
                                   tractId=outputDataId['tract'],
                                   patchId=outputDataId['patch'])

if self.config.doSelectVisits:
    warpRefList = self.filterWarps(inputData['inputWarps'], inputData['selectedVisits'])
else:
    warpRefList = inputData['inputWarps']

# Perform same middle steps as `runDataRef` does
inputs = self.prepareInputs(warpRefList)
self.log.info("Found %d %s", len(inputs.tempExpRefList),
              self.getTempExpDatasetName(self.warpType))
if len(inputs.tempExpRefList) == 0:
    raise pipeBase.NoWorkFound("No coadd temporary exposures found")

supplementaryData = self.makeSupplementaryDataGen3(butlerQC, inputRefs, outputRefs)
retStruct = self.run(inputData['skyInfo'], inputs.tempExpRefList, inputs.imageScalerList,
                     inputs.weightList, supplementaryData=supplementaryData)

inputData.setdefault('brightObjectMask', None)
self.processResults(retStruct.coaddExposure, inputData['brightObjectMask'], outputDataId)

if self.config.doWrite:
    butlerQC.put(retStruct, outputRefs)
return retStruct

@timeMethod
def runDataRef(self, dataRef, selectDataList=None, warpRefList=None):

Definition at line 531 of file assembleCoadd.py.

supplementaryData

lsst.pipe.tasks.assembleCoadd.supplementaryData

Definition at line 548 of file assembleCoadd.py.

tract

lsst.pipe.tasks.assembleCoadd.tract

Definition at line 381 of file assembleCoadd.py.

visit

lsst.pipe.tasks.assembleCoadd.visit

Definition at line 382 of file assembleCoadd.py.

warpRefList

lsst.pipe.tasks.assembleCoadd.warpRefList

Definition at line 539 of file assembleCoadd.py.

warpType

lsst.pipe.tasks.assembleCoadd.warpType

Definition at line 914 of file assembleCoadd.py.