Classes
class	GetCoaddAsTemplateConfig

class	GetCoaddAsTemplateTask

class	GetCalexpAsTemplateConfig

class	GetCalexpAsTemplateTask

class	GetMultiTractCoaddTemplateConnections

Functions
def	run (self, coaddExposures, bbox, wcs)

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

int	overlappingArea = 0

list	coaddExposureList = []

	dataId = coaddRef.dataId

	patchWcs = inputs['skyMap'][dataId['tract']].getWcs()

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

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

	patchPolygon = afwGeom.Polygon(inputs['wcs'].skyToPixel(patchCorners))

Function Documentation

◆ run()

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

Warp coadds from multiple tracts to form a template for image diff.

Where the tracts overlap, the resulting template image is averaged.
The PSF on the template is created by combining the CoaddPsf on each
template image into a meta-CoaddPsf.

Parameters
----------
coaddExposures: list of DeferredDatasetHandle to `lsst.afw.image.Exposure`
    Coadds to be mosaicked
bbox : `lsst.geom.Box2I`
    Template Bounding box of the detector geometry onto which to
    resample the coaddExposures
wcs : `lsst.afw.geom.SkyWcs`
    Template WCS onto which to resample the coaddExposures

Returns
-------
result : `struct`
    return a pipeBase.Struct:
    - ``outputExposure`` : a template coadd exposure assembled out of patches


Raises
------
NoWorkFound
    Raised if no patches overlatp the input detector bbox

Definition at line 603 of file getTemplate.py.

     def run(self, coaddExposures, bbox, wcs):
         """Warp coadds from multiple tracts to form a template for image diff.
  
         Where the tracts overlap, the resulting template image is averaged.
         The PSF on the template is created by combining the CoaddPsf on each
         template image into a meta-CoaddPsf.
  
         Parameters
         ----------
         coaddExposures: list of DeferredDatasetHandle to `lsst.afw.image.Exposure`
             Coadds to be mosaicked
         bbox : `lsst.geom.Box2I`
             Template Bounding box of the detector geometry onto which to
             resample the coaddExposures
         wcs : `lsst.afw.geom.SkyWcs`
             Template WCS onto which to resample the coaddExposures
  
         Returns
         -------
         result : `struct`
             return a pipeBase.Struct:
             - ``outputExposure`` : a template coadd exposure assembled out of patches
  
  
         Raises
         ------
         NoWorkFound
             Raised if no patches overlatp the input detector bbox
  
         """
         # Table for CoaddPSF
         tractsSchema = afwTable.ExposureTable.makeMinimalSchema()
         tractKey = tractsSchema.addField('tract', type=np.int32, doc='Which tract')
         patchKey = tractsSchema.addField('patch', type=np.int32, doc='Which patch')
         weightKey = tractsSchema.addField('weight', type=float, doc='Weight for each tract, should be 1')
         tractsCatalog = afwTable.ExposureCatalog(tractsSchema)
  
         finalWcs = wcs
         bbox.grow(self.config.templateBorderSize)
         finalBBox = bbox
  
         nPatchesFound = 0
         maskedImageList = []
         weightList = []
  
         for coaddExposure in coaddExposures:
             coaddPatch = coaddExposure.get()
  
             # warp to detector WCS
             warped = self.warper.warpExposure(finalWcs, coaddPatch, maxBBox=finalBBox)
  
             # Check if warped image is viable
             if not np.any(np.isfinite(warped.image.array)):
                 self.log.info("No overlap for warped %s. Skipping" % coaddExposure.ref.dataId)
                 continue
  
             exp = afwImage.ExposureF(finalBBox, finalWcs)
             exp.maskedImage.set(np.nan, afwImage.Mask.getPlaneBitMask("NO_DATA"), np.nan)
             exp.maskedImage.assign(warped.maskedImage, warped.getBBox())
  
             maskedImageList.append(exp.maskedImage)
             weightList.append(1)
             record = tractsCatalog.addNew()
             record.setPsf(coaddPatch.getPsf())
             record.setWcs(coaddPatch.getWcs())
             record.setPhotoCalib(coaddPatch.getPhotoCalib())
             record.setBBox(coaddPatch.getBBox())
             record.setValidPolygon(afwGeom.Polygon(geom.Box2D(coaddPatch.getBBox()).getCorners()))
             record.set(tractKey, coaddExposure.ref.dataId['tract'])
             record.set(patchKey, coaddExposure.ref.dataId['patch'])
             record.set(weightKey, 1.)
             nPatchesFound += 1
  
         if nPatchesFound == 0:
             raise pipeBase.NoWorkFound("No patches found to overlap detector")
  
         # Combine images from individual patches together
         statsFlags = afwMath.stringToStatisticsProperty('MEAN')
         statsCtrl = afwMath.StatisticsControl()
         statsCtrl.setNanSafe(True)
         statsCtrl.setWeighted(True)
         statsCtrl.setCalcErrorFromInputVariance(True)
  
         templateExposure = afwImage.ExposureF(finalBBox, finalWcs)
         templateExposure.maskedImage.set(np.nan, afwImage.Mask.getPlaneBitMask("NO_DATA"), np.nan)
         xy0 = templateExposure.getXY0()
         # Do not mask any values
         templateExposure.maskedImage = afwMath.statisticsStack(maskedImageList, statsFlags, statsCtrl,
                                                                weightList, clipped=0, maskMap=[])
         templateExposure.maskedImage.setXY0(xy0)
  
         # CoaddPsf centroid not only must overlap image, but must overlap the part of
         # image with data. Use centroid of region with data
         boolmask = templateExposure.mask.array & templateExposure.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(tractsCatalog, finalWcs, centerCoord, ctrl.warpingKernelName, ctrl.cacheSize)
         if coaddPsf is None:
             raise RuntimeError("CoaddPsf could not be constructed")
  
         templateExposure.setPsf(coaddPsf)
         templateExposure.setFilterLabel(coaddPatch.getFilterLabel())
         templateExposure.setPhotoCalib(coaddPatch.getPhotoCalib())
         return pipeBase.Struct(outputExposure=templateExposure)

Variable Documentation

◆ coaddExposureList

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

Definition at line 585 of file getTemplate.py.

◆ dataId

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

Definition at line 587 of file getTemplate.py.

◆ detectorPolygon

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

Definition at line 583 of file getTemplate.py.

◆ overlappingArea

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

Definition at line 584 of file getTemplate.py.

◆ patchBBox

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

Definition at line 589 of file getTemplate.py.

◆ patchCorners

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

Definition at line 590 of file getTemplate.py.

◆ patchPolygon

lsst.ip.diffim.getTemplate.patchPolygon = afwGeom.Polygon(inputs['wcs'].skyToPixel(patchCorners))

Definition at line 591 of file getTemplate.py.

◆ patchWcs

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

Definition at line 588 of file getTemplate.py.

Classes

Functions

Variables