Inheritance diagram for lsst.ip.diffim.getTemplate.GetCoaddAsTemplateTask:

Public Member Functions
def	runDataRef (self, exposure, sensorRef, templateIdList=None)

def	runQuantum (self, exposure, butlerQC, skyMapRef, coaddExposureRefs)

def	getOverlapPatchList (self, exposure, skyMap)

def	run (self, tractInfo, patchList, skyCorners, availableCoaddRefs, sensorRef=None, visitInfo=None)

def	getCoaddDatasetName (self)

Static Public Attributes
	ConfigClass = GetCoaddAsTemplateConfig

Detailed Description

Subtask to retrieve coadd for use as an image difference template.

This is the default getTemplate Task to be run as a subtask by
``pipe.tasks.ImageDifferenceTask``. The main methods are ``run()`` and
``runGen3()``.

Notes
-----
From the given skymap, the closest tract is selected;  multiple tracts  are
not supported. The assembled template inherits the WCS of the selected
skymap tract and the resolution of the template exposures. Overlapping box
regions of the input template patches are pixel by pixel copied into the
assembled template image. There is no warping or pixel resampling.

Pixels with no overlap of any available input patches are set to ``nan`` value
and ``NO_DATA`` flagged.

Definition at line 82 of file getTemplate.py.

Member Function Documentation

◆ getCoaddDatasetName()

def lsst.ip.diffim.getTemplate.GetCoaddAsTemplateTask.getCoaddDatasetName ( self )

Return coadd name for given task config

Returns
-------
CoaddDatasetName : `string`

TODO: This nearly duplicates a method in CoaddBaseTask (DM-11985)

Definition at line 393 of file getTemplate.py.

     def getCoaddDatasetName(self):
         """Return coadd name for given task config
  
         Returns
         -------
         CoaddDatasetName : `string`
  
         TODO: This nearly duplicates a method in CoaddBaseTask (DM-11985)
         """
         warpType = self.config.warpType
         suffix = "" if warpType == "direct" else warpType[0].upper() + warpType[1:]
         return self.config.coaddName + "Coadd" + suffix
  
  

◆ getOverlapPatchList()

def lsst.ip.diffim.getTemplate.GetCoaddAsTemplateTask.getOverlapPatchList	(	self,
		exposure,
		skyMap
	)

Select the relevant tract and its patches that overlap with the science exposure.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    The science exposure to define the sky region of the template coadd.

skyMap : `lsst.skymap.BaseSkyMap`
    SkyMap object that corresponds to the template coadd.

Returns
-------
result : `tuple` of
 - ``tractInfo`` : `lsst.skymap.TractInfo`
     The selected tract.
 - ``patchList`` : `list` of `lsst.skymap.PatchInfo`
     List of all overlap patches of the selected tract.
 - ``skyCorners`` : `list` of `lsst.geom.SpherePoint`
     Corners of the exposure in the sky in the order given by `lsst.geom.Box2D.getCorners`.

Definition at line 225 of file getTemplate.py.

     def getOverlapPatchList(self, exposure, skyMap):
         """Select the relevant tract and its patches that overlap with the science exposure.
  
         Parameters
         ----------
         exposure : `lsst.afw.image.Exposure`
             The science exposure to define the sky region of the template coadd.
  
         skyMap : `lsst.skymap.BaseSkyMap`
             SkyMap object that corresponds to the template coadd.
  
         Returns
         -------
         result : `tuple` of
          - ``tractInfo`` : `lsst.skymap.TractInfo`
              The selected tract.
          - ``patchList`` : `list` of `lsst.skymap.PatchInfo`
              List of all overlap patches of the selected tract.
          - ``skyCorners`` : `list` of `lsst.geom.SpherePoint`
              Corners of the exposure in the sky in the order given by `lsst.geom.Box2D.getCorners`.
         """
         expWcs = exposure.getWcs()
         expBoxD = geom.Box2D(exposure.getBBox())
         expBoxD.grow(self.config.templateBorderSize)
         ctrSkyPos = expWcs.pixelToSky(expBoxD.getCenter())
         tractInfo = skyMap.findTract(ctrSkyPos)
         self.log.info("Using skyMap tract %s", tractInfo.getId())
         skyCorners = [expWcs.pixelToSky(pixPos) for pixPos in expBoxD.getCorners()]
         patchList = tractInfo.findPatchList(skyCorners)
  
         if not patchList:
             raise RuntimeError("No suitable tract found")
  
         self.log.info("Assembling %d coadd patches", len(patchList))
         self.log.info("exposure dimensions=%s", exposure.getDimensions())
  
         return (tractInfo, patchList, skyCorners)
  

◆ run()

def lsst.ip.diffim.getTemplate.GetCoaddAsTemplateTask.run	(	self,
		tractInfo,
		patchList,
		skyCorners,
		availableCoaddRefs,
		sensorRef = `None`,
		visitInfo = `None`
	)

Gen2 and gen3 shared code: determination of exposure dimensions and
copying of pixels from overlapping patch regions.

Parameters
----------
skyMap : `lsst.skymap.BaseSkyMap`
    SkyMap object that corresponds to the template coadd.
tractInfo : `lsst.skymap.TractInfo`
    The selected tract.
patchList : iterable of `lsst.skymap.patchInfo.PatchInfo`
    Patches to consider for making the template exposure.
skyCorners : list of `lsst.geom.SpherePoint`
    Sky corner coordinates to be covered by the template exposure.
availableCoaddRefs : `dict` [`int`]
    Dictionary of spatially relevant retrieved coadd patches,
    indexed by their sequential patch number. In Gen3 mode, values are
    `lsst.daf.butler.DeferredDatasetHandle` and ``.get()`` is called,
    in Gen2 mode, ``sensorRef.get(**coaddef)`` is called to retrieve the coadd.
sensorRef : `lsst.daf.persistence.ButlerDataRef`, Gen2 only
    Butler data reference to get coadd data.
    Must be `None` for Gen3.
visitInfo : `lsst.afw.image.VisitInfo`, Gen2 only
    VisitInfo to make dcr model.

Returns
-------
templateExposure: `lsst.afw.image.ExposureF`
    The created template exposure.

Definition at line 263 of file getTemplate.py.

             sensorRef=None, visitInfo=None):
         """Gen2 and gen3 shared code: determination of exposure dimensions and
         copying of pixels from overlapping patch regions.
  
         Parameters
         ----------
         skyMap : `lsst.skymap.BaseSkyMap`
             SkyMap object that corresponds to the template coadd.
         tractInfo : `lsst.skymap.TractInfo`
             The selected tract.
         patchList : iterable of `lsst.skymap.patchInfo.PatchInfo`
             Patches to consider for making the template exposure.
         skyCorners : list of `lsst.geom.SpherePoint`
             Sky corner coordinates to be covered by the template exposure.
         availableCoaddRefs : `dict` [`int`]
             Dictionary of spatially relevant retrieved coadd patches,
             indexed by their sequential patch number. In Gen3 mode, values are
             `lsst.daf.butler.DeferredDatasetHandle` and ``.get()`` is called,
             in Gen2 mode, ``sensorRef.get(**coaddef)`` is called to retrieve the coadd.
         sensorRef : `lsst.daf.persistence.ButlerDataRef`, Gen2 only
             Butler data reference to get coadd data.
             Must be `None` for Gen3.
         visitInfo : `lsst.afw.image.VisitInfo`, Gen2 only
             VisitInfo to make dcr model.
  
         Returns
         -------
         templateExposure: `lsst.afw.image.ExposureF`
             The created template exposure.
         """
         coaddWcs = tractInfo.getWcs()
  
         # compute coadd bbox
         coaddBBox = geom.Box2D()
         for skyPos in skyCorners:
             coaddBBox.include(coaddWcs.skyToPixel(skyPos))
         coaddBBox = geom.Box2I(coaddBBox)
         self.log.info("coadd dimensions=%s", coaddBBox.getDimensions())
  
         coaddExposure = afwImage.ExposureF(coaddBBox, coaddWcs)
         coaddExposure.maskedImage.set(np.nan, afwImage.Mask.getPlaneBitMask("NO_DATA"), np.nan)
         nPatchesFound = 0
         coaddFilterLabel = None
         coaddPsf = None
         coaddPhotoCalib = None
         for patchInfo in patchList:
             patchNumber = tractInfo.getSequentialPatchIndex(patchInfo)
             patchSubBBox = patchInfo.getOuterBBox()
             patchSubBBox.clip(coaddBBox)
             if patchNumber not in availableCoaddRefs:
                 self.log.warning("skip patch=%d; patch does not exist for this coadd", patchNumber)
                 continue
             if patchSubBBox.isEmpty():
                 if isinstance(availableCoaddRefs[patchNumber], DeferredDatasetHandle):
                     tract = availableCoaddRefs[patchNumber].dataId['tract']
                 else:
                     tract = availableCoaddRefs[patchNumber]['tract']
                 self.log.info("skip tract=%d patch=%d; no overlapping pixels", tract, patchNumber)
                 continue
  
             if self.config.coaddName == 'dcr':
                 patchInnerBBox = patchInfo.getInnerBBox()
                 patchInnerBBox.clip(coaddBBox)
                 if np.min(patchInnerBBox.getDimensions()) <= 2*self.config.templateBorderSize:
                     self.log.info("skip tract=%(tract)s, patch=%(patch)s; too few pixels.",
                                   availableCoaddRefs[patchNumber])
                     continue
                 self.log.info("Constructing DCR-matched template for patch %s",
                               availableCoaddRefs[patchNumber])
  
                 if sensorRef:
                     dcrModel = DcrModel.fromDataRef(sensorRef,
                                                     self.config.effectiveWavelength,
                                                     self.config.bandwidth,
                                                     **availableCoaddRefs[patchNumber])
                 else:
                     dcrModel = DcrModel.fromQuantum(availableCoaddRefs[patchNumber],
                                                     self.config.effectiveWavelength,
                                                     self.config.bandwidth)
                 # The edge pixels of the DcrCoadd may contain artifacts due to missing data.
                 # Each patch has significant overlap, and the contaminated edge pixels in
                 # a new patch will overwrite good pixels in the overlap region from
                 # previous patches.
                 # Shrink the BBox to remove the contaminated pixels,
                 # but make sure it is only the overlap region that is reduced.
                 dcrBBox = geom.Box2I(patchSubBBox)
                 dcrBBox.grow(-self.config.templateBorderSize)
                 dcrBBox.include(patchInnerBBox)
                 coaddPatch = dcrModel.buildMatchedExposure(bbox=dcrBBox,
                                                            wcs=coaddWcs,
                                                            visitInfo=visitInfo)
             else:
                 if sensorRef is None:
                     # Gen3
                     coaddPatch = availableCoaddRefs[patchNumber].get()
                 else:
                     # Gen2
                     coaddPatch = sensorRef.get(**availableCoaddRefs[patchNumber])
             nPatchesFound += 1
  
             # Gen2 get() seems to clip based on bbox kwarg but we removed bbox
             # calculation from caller code. Gen3 also does not do this.
             overlapBox = coaddPatch.getBBox()
             overlapBox.clip(coaddBBox)
             coaddExposure.maskedImage.assign(coaddPatch.maskedImage[overlapBox], overlapBox)
  
             if coaddFilterLabel is None:
                 coaddFilterLabel = coaddPatch.getFilterLabel()
  
             # Retrieve the PSF for this coadd tract, if not already retrieved
             if coaddPsf is None and coaddPatch.hasPsf():
                 coaddPsf = coaddPatch.getPsf()
  
             # Retrieve the calibration for this coadd tract, if not already retrieved
             if coaddPhotoCalib is None:
                 coaddPhotoCalib = coaddPatch.getPhotoCalib()
  
         if coaddPhotoCalib is None:
             raise RuntimeError("No coadd PhotoCalib found!")
         if nPatchesFound == 0:
             raise RuntimeError("No patches found!")
         if coaddPsf is None:
             raise RuntimeError("No coadd Psf found!")
  
         coaddExposure.setPhotoCalib(coaddPhotoCalib)
         coaddExposure.setPsf(coaddPsf)
         coaddExposure.setFilterLabel(coaddFilterLabel)
         return coaddExposure
  

◆ runDataRef()

def lsst.ip.diffim.getTemplate.GetCoaddAsTemplateTask.runDataRef	(	self,
		exposure,
		sensorRef,
		templateIdList = `None`
	)

Gen2 task entry point. Retrieve and mosaic a template coadd exposure
that overlaps the science exposure.

Parameters
----------
exposure: `lsst.afw.image.Exposure`
    an exposure for which to generate an overlapping template
sensorRef : TYPE
    a Butler data reference that can be used to obtain coadd data
templateIdList : TYPE, optional
    list of data ids, unused here, in the case of coadd template

Returns
-------
result : `lsst.pipe.base.Struct`
    - ``exposure`` : `lsst.afw.image.ExposureF`
        a template coadd exposure assembled out of patches
    - ``sources`` :  None for this subtask

Definition at line 104 of file getTemplate.py.

     def runDataRef(self, exposure, sensorRef, templateIdList=None):
         """Gen2 task entry point. Retrieve and mosaic a template coadd exposure
         that overlaps the science exposure.
  
         Parameters
         ----------
         exposure: `lsst.afw.image.Exposure`
             an exposure for which to generate an overlapping template
         sensorRef : TYPE
             a Butler data reference that can be used to obtain coadd data
         templateIdList : TYPE, optional
             list of data ids, unused here, in the case of coadd template
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             - ``exposure`` : `lsst.afw.image.ExposureF`
                 a template coadd exposure assembled out of patches
             - ``sources`` :  None for this subtask
         """
         skyMap = sensorRef.get(datasetType=self.config.coaddName + "Coadd_skyMap")
         tractInfo, patchList, skyCorners = self.getOverlapPatchList(exposure, skyMap)
  
         availableCoaddRefs = dict()
         for patchInfo in patchList:
             patchNumber = tractInfo.getSequentialPatchIndex(patchInfo)
             patchArgDict = dict(
                 datasetType=self.getCoaddDatasetName() + "_sub",
                 bbox=patchInfo.getOuterBBox(),
                 tract=tractInfo.getId(),
                 patch="%s,%s" % (patchInfo.getIndex()[0], patchInfo.getIndex()[1]),
                 subfilter=0,
                 numSubfilters=self.config.numSubfilters,
             )
  
             if sensorRef.datasetExists(**patchArgDict):
                 self.log.info("Reading patch %s", patchArgDict)
                 availableCoaddRefs[patchNumber] = patchArgDict
  
         templateExposure = self.run(
             tractInfo, patchList, skyCorners, availableCoaddRefs,
             sensorRef=sensorRef, visitInfo=exposure.getInfo().getVisitInfo()
         )
         return pipeBase.Struct(exposure=templateExposure, sources=None)
  

◆ runQuantum()

def lsst.ip.diffim.getTemplate.GetCoaddAsTemplateTask.runQuantum	(	self,
		exposure,
		butlerQC,
		skyMapRef,
		coaddExposureRefs
	)

Gen3 task entry point. Retrieve and mosaic a template coadd exposure
that overlaps the science exposure.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    The science exposure to define the sky region of the template coadd.
butlerQC : `lsst.pipe.base.ButlerQuantumContext`
    Butler like object that supports getting data by DatasetRef.
skyMapRef : `lsst.daf.butler.DatasetRef`
    Reference to SkyMap object that corresponds to the template coadd.
coaddExposureRefs : iterable of `lsst.daf.butler.DeferredDatasetRef`
    Iterable of references to the available template coadd patches.

Returns
-------
result : `lsst.pipe.base.Struct`
    - ``exposure`` : `lsst.afw.image.ExposureF`
        a template coadd exposure assembled out of patches
    - ``sources`` :  `None` for this subtask

Definition at line 149 of file getTemplate.py.

     def runQuantum(self, exposure, butlerQC, skyMapRef, coaddExposureRefs):
         """Gen3 task entry point. Retrieve and mosaic a template coadd exposure
         that overlaps the science exposure.
  
         Parameters
         ----------
         exposure : `lsst.afw.image.Exposure`
             The science exposure to define the sky region of the template coadd.
         butlerQC : `lsst.pipe.base.ButlerQuantumContext`
             Butler like object that supports getting data by DatasetRef.
         skyMapRef : `lsst.daf.butler.DatasetRef`
             Reference to SkyMap object that corresponds to the template coadd.
         coaddExposureRefs : iterable of `lsst.daf.butler.DeferredDatasetRef`
             Iterable of references to the available template coadd patches.
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             - ``exposure`` : `lsst.afw.image.ExposureF`
                 a template coadd exposure assembled out of patches
             - ``sources`` :  `None` for this subtask
         """
         skyMap = butlerQC.get(skyMapRef)
         coaddExposureRefs = butlerQC.get(coaddExposureRefs)
         tracts = [ref.dataId['tract'] for ref in coaddExposureRefs]
         if tracts.count(tracts[0]) == len(tracts):
             tractInfo = skyMap[tracts[0]]
         else:
             raise RuntimeError("Templates constructed from multiple Tracts not supported by this task. "
                                "Use GetMultiTractCoaddTemplateTask instead.")
  
         detectorBBox = exposure.getBBox()
         detectorWcs = exposure.getWcs()
         detectorCorners = detectorWcs.pixelToSky(geom.Box2D(detectorBBox).getCorners())
         validPolygon = exposure.getInfo().getValidPolygon()
         detectorPolygon = validPolygon if validPolygon else geom.Box2D(detectorBBox)
  
         availableCoaddRefs = dict()
         overlappingArea = 0
         for coaddRef in coaddExposureRefs:
             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(detectorWcs.skyToPixel(patchCorners))
             if patchPolygon.intersection(detectorPolygon):
                 overlappingArea += patchPolygon.intersectionSingle(detectorPolygon).calculateArea()
                 if self.config.coaddName == 'dcr':
                     self.log.info("Using template input tract=%s, patch=%s, subfilter=%s",
                                   dataId['tract'], dataId['patch'], dataId['subfilter'])
                     if dataId['patch'] in availableCoaddRefs:
                         availableCoaddRefs[dataId['patch']].append(coaddRef)
                     else:
                         availableCoaddRefs[dataId['patch']] = [coaddRef, ]
                 else:
                     self.log.info("Using template input tract=%s, patch=%s",
                                   dataId['tract'], dataId['patch'])
                     availableCoaddRefs[dataId['patch']] = coaddRef
  
         if overlappingArea == 0:
             templateExposure = None
             pixGood = 0
             self.log.warning("No overlapping template patches found")
         else:
             patchList = [tractInfo[patch] for patch in availableCoaddRefs.keys()]
             templateExposure = self.run(tractInfo, patchList, detectorCorners, availableCoaddRefs,
                                         visitInfo=exposure.getInfo().getVisitInfo())
             # Count the number of pixels with the NO_DATA mask bit set
             # counting NaN pixels is insufficient because pixels without data are often intepolated over)
             pixNoData = np.count_nonzero(templateExposure.mask.array
                                          & templateExposure.mask.getPlaneBitMask('NO_DATA'))
             pixGood = templateExposure.getBBox().getArea() - pixNoData
             self.log.info("template has %d good pixels (%.1f%%)", pixGood,
                           100*pixGood/templateExposure.getBBox().getArea())
         return pipeBase.Struct(exposure=templateExposure, sources=None, area=pixGood)
  

Member Data Documentation

◆ ConfigClass

lsst.ip.diffim.getTemplate.GetCoaddAsTemplateTask.ConfigClass = GetCoaddAsTemplateConfig

static

Definition at line 101 of file getTemplate.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ip_diffim/22.0.1-24-g1ad7a390+a9625a72a8/python/lsst/ip/diffim/getTemplate.py

Public Member Functions

Static Public Attributes