Inheritance diagram for lsst.pipe.tasks.snapCombine.SnapCombineTask:

Public Member Functions
def	__init__ (self, args, *kwargs)

def	run (self, snap0, snap1, defects=None)

def	addSnaps (self, snap0, snap1)

def	fixMetadata (self, combinedMetadata, metadata0, metadata1)

def	makeInitialPsf (self, exposure, fwhmPix=None)

Public Attributes
	schema

	algMetadata

Static Public Attributes
	ConfigClass = SnapCombineConfig

Detailed Description

Combine snaps.

Debug variables

The command line task interface supports a flag -d to import debug.py from your PYTHONPATH; see Debugging Tasks with lsstDebug for more about debug.py files.

The available variables in SnapCombineTask are:

display

A dictionary containing debug point names as keys with frame number as value. Valid keys are:

repair0: Display the first snap after repairing.
repair1: Display the second snap after repairing.

Definition at line 136 of file snapCombine.py.

Constructor & Destructor Documentation

◆ init()

def lsst.pipe.tasks.snapCombine.SnapCombineTask.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 169 of file snapCombine.py.

     def __init__(self, *args, **kwargs):
         pipeBase.Task.__init__(self, *args, **kwargs)
         self.makeSubtask("repair")
         self.makeSubtask("diffim")
         self.schema = afwTable.SourceTable.makeMinimalSchema()
         self.algMetadata = dafBase.PropertyList()
         self.makeSubtask("detection", schema=self.schema)
         if self.config.doMeasurement:
             self.makeSubtask("measurement", schema=self.schema, algMetadata=self.algMetadata)
  

Member Function Documentation

◆ addSnaps()

def lsst.pipe.tasks.snapCombine.SnapCombineTask.addSnaps	(	self,
		snap0,
		snap1
	)

Add two snap exposures together, returning a new exposure

@param[in] snap0 snap exposure 0
@param[in] snap1 snap exposure 1
@return combined exposure

Definition at line 250 of file snapCombine.py.

     def addSnaps(self, snap0, snap1):
         """Add two snap exposures together, returning a new exposure
  
         @param[in] snap0 snap exposure 0
         @param[in] snap1 snap exposure 1
         @return combined exposure
         """
         self.log.info("snapCombine addSnaps")
  
         combinedExp = snap0.Factory(snap0, True)
         combinedMi = combinedExp.getMaskedImage()
         combinedMi.set(0)
  
         weightMap = combinedMi.getImage().Factory(combinedMi.getBBox())
         weight = 1.0
         badPixelMask = afwImage.Mask.getPlaneBitMask(self.config.badMaskPlanes)
         addToCoadd(combinedMi, weightMap, snap0.getMaskedImage(), badPixelMask, weight)
         addToCoadd(combinedMi, weightMap, snap1.getMaskedImage(), badPixelMask, weight)
  
         # pre-scaling the weight map instead of post-scaling the combinedMi saves a bit of time
         # because the weight map is a simple Image instead of a MaskedImage
         weightMap *= 0.5  # so result is sum of both images, instead of average
         combinedMi /= weightMap
         setCoaddEdgeBits(combinedMi.getMask(), weightMap)
  
         # note: none of the inputs has a valid PhotoCalib object, so that is not touched
         # Filter was already copied
  
         combinedMetadata = combinedExp.getMetadata()
         metadata0 = snap0.getMetadata()
         metadata1 = snap1.getMetadata()
         self.fixMetadata(combinedMetadata, metadata0, metadata1)
  
         return combinedExp
  

◆ fixMetadata()

def lsst.pipe.tasks.snapCombine.SnapCombineTask.fixMetadata	(	self,
		combinedMetadata,
		metadata0,
		metadata1
	)

Fix the metadata of the combined exposure (in place)

This implementation handles items specified by config.averageKeys and config.sumKeys,
which have data type restrictions. To handle other data types (such as sexagesimal
positions and ISO dates) you must supplement this method with your own code.

@param[in,out] combinedMetadata metadata of combined exposure;
    on input this is a deep copy of metadata0 (a PropertySet)
@param[in] metadata0 metadata of snap0 (a PropertySet)
@param[in] metadata1 metadata of snap1 (a PropertySet)

@note the inputs are presently PropertySets due to ticket #2542. However, in some sense
they are just PropertyLists that are missing some methods. In particular: comments and order
are preserved if you alter an existing value with set(key, value).

Definition at line 285 of file snapCombine.py.

     def fixMetadata(self, combinedMetadata, metadata0, metadata1):
         """Fix the metadata of the combined exposure (in place)
  
         This implementation handles items specified by config.averageKeys and config.sumKeys,
         which have data type restrictions. To handle other data types (such as sexagesimal
         positions and ISO dates) you must supplement this method with your own code.
  
         @param[in,out] combinedMetadata metadata of combined exposure;
             on input this is a deep copy of metadata0 (a PropertySet)
         @param[in] metadata0 metadata of snap0 (a PropertySet)
         @param[in] metadata1 metadata of snap1 (a PropertySet)
  
         @note the inputs are presently PropertySets due to ticket #2542. However, in some sense
         they are just PropertyLists that are missing some methods. In particular: comments and order
         are preserved if you alter an existing value with set(key, value).
         """
         keyDoAvgList = []
         if self.config.averageKeys:
             keyDoAvgList += [(key, 1) for key in self.config.averageKeys]
         if self.config.sumKeys:
             keyDoAvgList += [(key, 0) for key in self.config.sumKeys]
         for key, doAvg in keyDoAvgList:
             opStr = "average" if doAvg else "sum"
             try:
                 val0 = metadata0.getScalar(key)
                 val1 = metadata1.getScalar(key)
             except Exception:
                 self.log.warning("Could not %s metadata %r: missing from one or both exposures", opStr, key)
                 continue
  
             try:
                 combinedVal = val0 + val1
                 if doAvg:
                     combinedVal /= 2.0
             except Exception:
                 self.log.warning("Could not %s metadata %r: value %r and/or %r not numeric",
                                  opStr, key, val0, val1)
                 continue
  
             combinedMetadata.set(key, combinedVal)
  

◆ makeInitialPsf()

def lsst.pipe.tasks.snapCombine.SnapCombineTask.makeInitialPsf	(	self,
		exposure,
		fwhmPix = `None`
	)

Initialise the detection procedure by setting the PSF and WCS

@param exposure Exposure to process
@return PSF, WCS

Definition at line 326 of file snapCombine.py.

     def makeInitialPsf(self, exposure, fwhmPix=None):
         """Initialise the detection procedure by setting the PSF and WCS
  
         @param exposure Exposure to process
         @return PSF, WCS
         """
         assert exposure, "No exposure provided"
         wcs = exposure.getWcs()
         assert wcs, "No wcs in exposure"
  
         if fwhmPix is None:
             fwhmPix = self.config.initialPsf.fwhm / wcs.getPixelScale().asArcseconds()
  
         size = self.config.initialPsf.size
         model = self.config.initialPsf.model
         self.log.info("installInitialPsf fwhm=%s pixels; size=%s pixels", fwhmPix, size)
         psfCls = getattr(measAlg, model + "Psf")
         psf = psfCls(size, size, fwhmPix/(2.0*num.sqrt(2*num.log(2.0))))
         return psf

◆ run()

def lsst.pipe.tasks.snapCombine.SnapCombineTask.run	(	self,
		snap0,
		snap1,
		defects = `None`
	)

Combine two snaps

@param[in] snap0: snapshot exposure 0
@param[in] snap1: snapshot exposure 1
@defects[in] defect list (for repair task)
@return a pipe_base Struct with fields:
- exposure: snap-combined exposure
- sources: detected sources, or None if detection not performed

Definition at line 180 of file snapCombine.py.

     def run(self, snap0, snap1, defects=None):
         """Combine two snaps
  
         @param[in] snap0: snapshot exposure 0
         @param[in] snap1: snapshot exposure 1
         @defects[in] defect list (for repair task)
         @return a pipe_base Struct with fields:
         - exposure: snap-combined exposure
         - sources: detected sources, or None if detection not performed
         """
         # initialize optional outputs
         sources = None
  
         if self.config.doRepair:
             self.log.info("snapCombine repair")
             psf = self.makeInitialPsf(snap0, fwhmPix=self.config.repairPsfFwhm)
             snap0.setPsf(psf)
             snap1.setPsf(psf)
             self.repair.run(snap0, defects=defects, keepCRs=False)
             self.repair.run(snap1, defects=defects, keepCRs=False)
  
             repair0frame = getDebugFrame(self._display, "repair0")
             if repair0frame:
                 getDisplay(repair0frame).mtv(snap0)
             repair1frame = getDebugFrame(self._display, "repair1")
             if repair1frame:
                 getDisplay(repair1frame).mtv(snap1)
  
         if self.config.doDiffIm:
             if self.config.doPsfMatch:
                 self.log.info("snapCombine psfMatch")
                 diffRet = self.diffim.run(snap0, snap1, "subtractExposures")
                 diffExp = diffRet.subtractedImage
  
                 # Measure centroid and width of kernel; dependent on ticket #1980
                 # Useful diagnostic for the degree of astrometric shift between snaps.
                 diffKern = diffRet.psfMatchingKernel
                 width, height = diffKern.getDimensions()
  
             else:
                 diffExp = afwImage.ExposureF(snap0, True)
                 diffMi = diffExp.getMaskedImage()
                 diffMi -= snap1.getMaskedImage()
  
             psf = self.makeInitialPsf(snap0)
             diffExp.setPsf(psf)
             table = afwTable.SourceTable.make(self.schema)
             table.setMetadata(self.algMetadata)
             detRet = self.detection.run(table, diffExp)
             sources = detRet.sources
             fpSets = detRet.fpSets
             if self.config.doMeasurement:
                 self.measurement.measure(diffExp, sources)
  
             mask0 = snap0.getMaskedImage().getMask()
             mask1 = snap1.getMaskedImage().getMask()
             fpSets.positive.setMask(mask0, "DETECTED")
             fpSets.negative.setMask(mask1, "DETECTED")
  
             maskD = diffExp.getMaskedImage().getMask()
             fpSets.positive.setMask(maskD, "DETECTED")
             fpSets.negative.setMask(maskD, "DETECTED_NEGATIVE")
  
         combinedExp = self.addSnaps(snap0, snap1)
  
         return pipeBase.Struct(
             exposure=combinedExp,
             sources=sources,
         )
  

Member Data Documentation

◆ algMetadata

lsst.pipe.tasks.snapCombine.SnapCombineTask.algMetadata

Definition at line 174 of file snapCombine.py.

◆ ConfigClass

lsst.pipe.tasks.snapCombine.SnapCombineTask.ConfigClass = SnapCombineConfig

static

Definition at line 166 of file snapCombine.py.

◆ schema

lsst.pipe.tasks.snapCombine.SnapCombineTask.schema

Definition at line 173 of file snapCombine.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/pipe_tasks/21.0.0-172-gfb10e10a+18fedfabac/python/lsst/pipe/tasks/snapCombine.py

Public Member Functions

Public Attributes

Static Public Attributes