Classes
class	GetDcrTemplateConnections

class	GetTemplateConnections

Functions
	run (self, coaddExposures, bbox, wcs, dataIds, physical_filter)

	_makeExposureCatalog (self, exposures, dataIds)

	_merge (self, maskedImages, bbox, wcs)

	_makePsf (self, template, catalog, wcs)

	checkPatchList (self, patchList)

	getDcrModel (self, patchList, coaddRefs, visitInfo)

	_selectDataRef (coaddRef, tract, patch)

Variables
	detectorPolygon = geom.Box2D(inputs['bbox'])

int	overlappingArea = 0

	coaddExposures = collections.defaultdict(list)

	dataIds = collections.defaultdict(list)

	skymap = inputs['skyMap']

	dataId = coaddRef.dataId

	patchWcs = skymap[dataId['tract']].getWcs()

	patchBBox = skymap[dataId['tract']][dataId['patch']].getOuterBBox()

	patchCorners = patchWcs.pixelToSky(geom.Box2D(patchBBox).getCorners())

	patchPolygon = afwGeom.Polygon(wcs.skyToPixel(patchCorners))

list	coaddExposureRefList = []

	patchList = dict()

Function Documentation

◆ _makeExposureCatalog()

lsst.ip.diffim.getTemplate._makeExposureCatalog	(	self,
		exposures,
		dataIds )

protected

Make an exposure catalog for one tract.

Parameters
----------
exposures : `list` [`lsst.afw.image.Exposuref`]
    Exposures to include in the catalog.
dataIds : `list` [`lsst.daf.butler.DataCoordinate`]
    Data ids of each of the included exposures; must have "tract" and
    "patch" entries.

Returns
-------
images : `list` [`lsst.afw.image.MaskedImage`]
    MaskedImages of each of the input exposures, for warping.
catalog : `lsst.afw.table.ExposureCatalog`
    Catalog of metadata for each exposure
totalBox : `lsst.geom.Box2I`
    The union of the bounding boxes of all the input exposures.

Definition at line 313 of file getTemplate.py.

    def _makeExposureCatalog(self, exposures, dataIds):
        """Make an exposure catalog for one tract.
 
        Parameters
        ----------
        exposures : `list` [`lsst.afw.image.Exposuref`]
            Exposures to include in the catalog.
        dataIds : `list` [`lsst.daf.butler.DataCoordinate`]
            Data ids of each of the included exposures; must have "tract" and
            "patch" entries.
 
        Returns
        -------
        images : `list` [`lsst.afw.image.MaskedImage`]
            MaskedImages of each of the input exposures, for warping.
        catalog : `lsst.afw.table.ExposureCatalog`
            Catalog of metadata for each exposure
        totalBox : `lsst.geom.Box2I`
            The union of the bounding boxes of all the input exposures.
        """
        catalog = afwTable.ExposureCatalog(self.schema)
        catalog.reserve(len(exposures))
        images = [exposure.maskedImage for exposure in exposures]
        totalBox = geom.Box2I()
        for coadd, dataId in zip(exposures, dataIds):
            totalBox = totalBox.expandedTo(coadd.getBBox())
            record = catalog.addNew()
            record.setPsf(coadd.psf)
            record.setWcs(coadd.wcs)
            record.setPhotoCalib(coadd.photoCalib)
            record.setBBox(coadd.getBBox())
            record.setValidPolygon(afwGeom.Polygon(geom.Box2D(coadd.getBBox()).getCorners()))
            record.set("tract", dataId["tract"])
            record.set("patch", dataId["patch"])
            # Weight is used by CoaddPsf, but the PSFs from overlapping patches
            # should be very similar, so this value mostly shouldn't matter.
            record.set("weight", 1)
 
        return images, catalog, totalBox
 

◆ _makePsf()

lsst.ip.diffim.getTemplate._makePsf	(	self,
		template,
		catalog,
		wcs )

protected

Return a PSF containing the PSF at each of the input regions.

Note that although this includes all the exposures from the catalog,
the PSF knows which part of the template the inputs came from, so when
evaluated at a given position it will not include inputs that never
went in to those pixels.

Parameters
----------
template : `lsst.afw.image.Exposure`
    Generated template the PSF is for.
catalog : `lsst.afw.table.ExposureCatalog`
    Catalog of exposures that went into the template that contains all
    of the input PSFs.
wcs : `lsst.afw.geom.SkyWcs`
    WCS of the template, to warp the PSFs to.

Returns
-------
coaddPsf : `lsst.meas.algorithms.CoaddPsf`
    The meta-psf constructed from all of the input catalogs.

Definition at line 403 of file getTemplate.py.

    def _makePsf(self, template, catalog, wcs):
        """Return a PSF containing the PSF at each of the input regions.
 
        Note that although this includes all the exposures from the catalog,
        the PSF knows which part of the template the inputs came from, so when
        evaluated at a given position it will not include inputs that never
        went in to those pixels.
 
        Parameters
        ----------
        template : `lsst.afw.image.Exposure`
            Generated template the PSF is for.
        catalog : `lsst.afw.table.ExposureCatalog`
            Catalog of exposures that went into the template that contains all
            of the input PSFs.
        wcs : `lsst.afw.geom.SkyWcs`
            WCS of the template, to warp the PSFs to.
 
        Returns
        -------
        coaddPsf : `lsst.meas.algorithms.CoaddPsf`
            The meta-psf constructed from all of the input catalogs.
        """
        # CoaddPsf centroid not only must overlap image, but must overlap the
        # part of image with data. Use centroid of region with data.
        boolmask = template.mask.array & template.mask.getPlaneBitMask('NO_DATA') == 0
        maskx = afwImage.makeMaskFromArray(boolmask.astype(afwImage.MaskPixel))
        centerCoord = afwGeom.SpanSet.fromMask(maskx, 1).computeCentroid()
 
        ctrl = self.config.coaddPsf.makeControl()
        coaddPsf = CoaddPsf(catalog, wcs, centerCoord, ctrl.warpingKernelName, ctrl.cacheSize)
        return coaddPsf
 
 

◆ _merge()

lsst.ip.diffim.getTemplate._merge	(	self,
		maskedImages,
		bbox,
		wcs )

protected

Merge the images that came from one tract into one larger image,
ignoring NaN pixels and non-finite variance pixels from individual
exposures.

Parameters
----------
maskedImages : `list` [`lsst.afw.image.MaskedImage`]
    Images to be merged into one larger bounding box.
bbox : `lsst.geom.Box2I`
    Bounding box defining the image to merge into.
wcs : `lsst.afw.geom.SkyWcs`
    WCS of all of the input images to set on the output image.

Returns
-------
merged : `lsst.afw.image.MaskedImage`
    Merged image with all of the inputs at their respective bbox
    positions.

Definition at line 353 of file getTemplate.py.

    def _merge(self, maskedImages, bbox, wcs):
        """Merge the images that came from one tract into one larger image,
        ignoring NaN pixels and non-finite variance pixels from individual
        exposures.
 
        Parameters
        ----------
        maskedImages : `list` [`lsst.afw.image.MaskedImage`]
            Images to be merged into one larger bounding box.
        bbox : `lsst.geom.Box2I`
            Bounding box defining the image to merge into.
        wcs : `lsst.afw.geom.SkyWcs`
            WCS of all of the input images to set on the output image.
 
        Returns
        -------
        merged : `lsst.afw.image.MaskedImage`
            Merged image with all of the inputs at their respective bbox
            positions.
        """
        merged = afwImage.ExposureF(bbox, wcs)
        weights = afwImage.ImageF(bbox)
        for maskedImage in maskedImages:
            weight = afwImage.ImageF(maskedImage.variance.array**(-0.5))
            bad = np.isnan(maskedImage.image.array) | ~np.isfinite(maskedImage.variance.array)
            # Note that modifying the patch MaskedImage in place is fine;
            # we're throwing it away at the end anyway.
            maskedImage.image.array[bad] = 0.0
            maskedImage.variance.array[bad] = 0.0
            # Reset mask, too, since these pixels don't contribute to sum.
            maskedImage.mask.array[bad] = 0
            # Cannot use `merged.maskedImage *= weight` because that operator
            # multiplies the variance by the weight twice; in this case
            # `weight` are the exact values we want to scale by.
            maskedImage.image *= weight
            maskedImage.variance *= weight
            merged.maskedImage[maskedImage.getBBox()] += maskedImage
            # Clear the NaNs to ensure that areas missing from this input are
            # masked with NO_DATA after the loop.
            weight.array[np.isnan(weight.array)] = 0
            weights[maskedImage.getBBox()] += weight
        # Cannot use `merged.maskedImage /= weights` because that operator
        # divides the variance by the weight twice; in this case `weights` are
        # the exact values we want to scale by.
        merged.image /= weights
        merged.variance /= weights
        merged.mask.array |= merged.mask.getPlaneBitMask("NO_DATA") * (weights.array == 0)
 
        return merged
 

◆ _selectDataRef()

lsst.ip.diffim.getTemplate._selectDataRef	(	coaddRef,
		tract,
		patch )

protected

Definition at line 620 of file getTemplate.py.

def _selectDataRef(coaddRef, tract, patch):
    condition = (coaddRef.dataId['tract'] == tract) & (coaddRef.dataId['patch'] == patch)
    return condition

◆ checkPatchList()

lsst.ip.diffim.getTemplate.checkPatchList	(		self,
			patchList )

Check that all of the DcrModel subfilters are present for each
patch.

Parameters
----------
patchList : `dict`
    Dict of the patches containing valid data for each tract.

Raises
------
RuntimeError
    If the number of exposures found for a patch does not match the
    number of subfilters.

Definition at line 567 of file getTemplate.py.

    def checkPatchList(self, patchList):
        """Check that all of the DcrModel subfilters are present for each
        patch.
 
        Parameters
        ----------
        patchList : `dict`
            Dict of the patches containing valid data for each tract.
 
        Raises
        ------
        RuntimeError
            If the number of exposures found for a patch does not match the
            number of subfilters.
        """
        for tract in patchList:
            for patch in set(patchList[tract]):
                if patchList[tract].count(patch) != self.config.numSubfilters:
                    raise RuntimeError("Invalid number of DcrModel subfilters found: %d vs %d expected",
                                       patchList[tract].count(patch), self.config.numSubfilters)
 

◆ getDcrModel()

lsst.ip.diffim.getTemplate.getDcrModel	(	self,
		patchList,
		coaddRefs,
		visitInfo )

Build DCR-matched coadds from a list of exposure references.

Parameters
----------
patchList : `dict`
    Dict of the patches containing valid data for each tract.
coaddRefs : `list` [`lsst.daf.butler.DeferredDatasetHandle`]
    Data references to `~lsst.afw.image.Exposure` representing
    DcrModels that overlap the detector.
visitInfo : `lsst.afw.image.VisitInfo`
    Metadata for the science image.

Returns
-------
coaddExposures : `list` [`lsst.afw.image.Exposure`]
    Coadd exposures that overlap the detector.

Definition at line 588 of file getTemplate.py.

    def getDcrModel(self, patchList, coaddRefs, visitInfo):
        """Build DCR-matched coadds from a list of exposure references.
 
        Parameters
        ----------
        patchList : `dict`
            Dict of the patches containing valid data for each tract.
        coaddRefs : `list` [`lsst.daf.butler.DeferredDatasetHandle`]
            Data references to `~lsst.afw.image.Exposure` representing
            DcrModels that overlap the detector.
        visitInfo : `lsst.afw.image.VisitInfo`
            Metadata for the science image.
 
        Returns
        -------
        coaddExposures : `list` [`lsst.afw.image.Exposure`]
            Coadd exposures that overlap the detector.
        """
        coaddExposures = []
        for tract in patchList:
            for patch in set(patchList[tract]):
                coaddRefList = [coaddRef for coaddRef in coaddRefs
                                if _selectDataRef(coaddRef, tract, patch)]
 
                dcrModel = DcrModel.fromQuantum(coaddRefList,
                                                self.config.effectiveWavelength,
                                                self.config.bandwidth,
                                                self.config.numSubfilters)
                coaddExposures.append(dcrModel.buildMatchedExposure(visitInfo=visitInfo))
        return coaddExposures
 
 

◆ run()

lsst.ip.diffim.getTemplate.run	(	self,
		coaddExposures,
		bbox,
		wcs,
		dataIds,
		physical_filter )

Warp coadds from multiple tracts and patches to form a template to
subtract from a science image.

Tract and patch overlap regions are combined by a variance-weighted
average, and the variance planes are combined with the same weights,
not added in quadrature; the overlap regions are not statistically
independent, because they're derived from the same original data.
The PSF on the template is created by combining the CoaddPsf on each
template image into a meta-CoaddPsf.

Parameters
----------
coaddExposures : `dict` [`int`, `list` [`lsst.afw.image.Exposure`]]
    Coadds to be mosaicked, indexed on tract id.
bbox : `lsst.geom.Box2I`
    Template Bounding box of the detector geometry onto which to
    resample the ``coaddExposures``. Modified in-place to include the
    template border.
wcs : `lsst.afw.geom.SkyWcs`
    Template WCS onto which to resample the ``coaddExposures``.
dataIds : `dict` [`int`, `list` [`lsst.daf.butler.DataCoordinate`]]
    Record of the tract and patch of each coaddExposure, indexed on
    tract id.
physical_filter : `str`
    Physical filter of the science image.

Returns
-------
result : `lsst.pipe.base.Struct`
   A struct with attributes:

   ``template``
       A template coadd exposure assembled out of patches
       (`lsst.afw.image.ExposureF`).

Raises
------
NoWorkFound
    If no coadds are found with sufficient un-masked pixels.

Definition at line 202 of file getTemplate.py.

    def run(self, coaddExposures, bbox, wcs, dataIds, physical_filter):
        """Warp coadds from multiple tracts and patches to form a template to
        subtract from a science image.
 
        Tract and patch overlap regions are combined by a variance-weighted
        average, and the variance planes are combined with the same weights,
        not added in quadrature; the overlap regions are not statistically
        independent, because they're derived from the same original data.
        The PSF on the template is created by combining the CoaddPsf on each
        template image into a meta-CoaddPsf.
 
        Parameters
        ----------
        coaddExposures : `dict` [`int`, `list` [`lsst.afw.image.Exposure`]]
            Coadds to be mosaicked, indexed on tract id.
        bbox : `lsst.geom.Box2I`
            Template Bounding box of the detector geometry onto which to
            resample the ``coaddExposures``. Modified in-place to include the
            template border.
        wcs : `lsst.afw.geom.SkyWcs`
            Template WCS onto which to resample the ``coaddExposures``.
        dataIds : `dict` [`int`, `list` [`lsst.daf.butler.DataCoordinate`]]
            Record of the tract and patch of each coaddExposure, indexed on
            tract id.
        physical_filter : `str`
            Physical filter of the science image.
 
        Returns
        -------
        result : `lsst.pipe.base.Struct`
           A struct with attributes:
 
           ``template``
               A template coadd exposure assembled out of patches
               (`lsst.afw.image.ExposureF`).
 
        Raises
        ------
        NoWorkFound
            If no coadds are found with sufficient un-masked pixels.
        """
        band, photoCalib = self._checkInputs(dataIds, coaddExposures)
 
        bbox.grow(self.config.templateBorderSize)
 
        warped = {}
        catalogs = []
        for tract in coaddExposures:
            maskedImages, catalog, totalBox = self._makeExposureCatalog(coaddExposures[tract],
                                                                        dataIds[tract])
            # Combine images from individual patches together.
            unwarped = self._merge(maskedImages, totalBox, catalog[0].wcs)
            potentialInput = self.warper.warpExposure(wcs, unwarped, destBBox=bbox)
            if not np.any(np.isfinite(potentialInput.image.array)):
                self.log.info("No overlap from coadds in tract %s; not including in output.", tract)
                continue
            catalogs.append(catalog)
            warped[tract] = potentialInput
            warped[tract].setWcs(wcs)
 
        if len(warped) == 0:
            raise pipeBase.NoWorkFound("No patches found to overlap science exposure.")
        template = self._merge([x.maskedImage for x in warped.values()], bbox, wcs)
 
        # Make a single catalog containing all the inputs that were accepted.
        catalog = afwTable.ExposureCatalog(self.schema)
        catalog.reserve(sum([len(c) for c in catalogs]))
        for c in catalogs:
            catalog.extend(c)
 
        template.setPsf(self._makePsf(template, catalog, wcs))
        template.setFilter(afwImage.FilterLabel(band, physical_filter))
        template.setPhotoCalib(photoCalib)
        return pipeBase.Struct(template=template)
 

Variable Documentation

◆ coaddExposureRefList

list lsst.ip.diffim.getTemplate.coaddExposureRefList = []

Definition at line 538 of file getTemplate.py.

◆ coaddExposures

lsst.ip.diffim.getTemplate.coaddExposures = collections.defaultdict(list)

Definition at line 179 of file getTemplate.py.

◆ dataId

lsst.ip.diffim.getTemplate.dataId = coaddRef.dataId

Definition at line 184 of file getTemplate.py.

◆ dataIds

list lsst.ip.diffim.getTemplate.dataIds = collections.defaultdict(list)

Definition at line 180 of file getTemplate.py.

◆ detectorPolygon

lsst.ip.diffim.getTemplate.detectorPolygon = geom.Box2D(inputs['bbox'])

Definition at line 177 of file getTemplate.py.

◆ overlappingArea

int lsst.ip.diffim.getTemplate.overlappingArea = 0

Definition at line 178 of file getTemplate.py.

◆ patchBBox

lsst.ip.diffim.getTemplate.patchBBox = skymap[dataId['tract']][dataId['patch']].getOuterBBox()

Definition at line 186 of file getTemplate.py.

◆ patchCorners

lsst.ip.diffim.getTemplate.patchCorners = patchWcs.pixelToSky(geom.Box2D(patchBBox).getCorners())

Definition at line 187 of file getTemplate.py.

◆ patchList

lsst.ip.diffim.getTemplate.patchList = dict()

Definition at line 540 of file getTemplate.py.

◆ patchPolygon

lsst.ip.diffim.getTemplate.patchPolygon = afwGeom.Polygon(wcs.skyToPixel(patchCorners))

Definition at line 188 of file getTemplate.py.

◆ patchWcs

lsst.ip.diffim.getTemplate.patchWcs = skymap[dataId['tract']].getWcs()

Definition at line 185 of file getTemplate.py.

◆ skymap

lsst.ip.diffim.getTemplate.skymap = inputs['skyMap']

Definition at line 182 of file getTemplate.py.

Classes

Functions

Variables

Function Documentation

◆ _makeExposureCatalog()

◆ _makePsf()

◆ _merge()

◆ _selectDataRef()

◆ checkPatchList()

◆ getDcrModel()

◆ run()

Variable Documentation

◆ coaddExposureRefList

◆ coaddExposures

◆ dataId

◆ dataIds

◆ detectorPolygon

◆ overlappingArea

◆ patchBBox

◆ patchCorners

◆ patchList

◆ patchPolygon

◆ patchWcs

◆ skymap